117

क्या इसे "हैलो, वर्ल्ड!" के लिए O (1) एल्गोरिथम के रूप में वर्गीकृत किया जाएगा। ??

public class Hello1
{
   public static void Main()
   {
      DateTime TwentyYearsLater = new DateTime(2035,01,01);
      while ( DateTime.Now < TwentyYearsLater )
      { 
          System.Console.WriteLine("It's still not time to print the hello ...");
      }
      System.Console.WriteLine("Hello, World!");
   }
}

मैं का उपयोग करने के बारे में सोच रहा हूँ

DateTime TwentyYearsLater = new DateTime(2035,01,01);
while ( DateTime.Now < TwentyYearsLater )
{ 
   // ... 
}

जब भी कोई व्यक्ति किसी निश्चित जटिलता के एल्गोरिथ्म के लिए पूछता है तो एक चुटकी के रूप में डालने के लिए कोड का स्निपेट। क्या यह सही होगा?

c# .net algorithm big-o

— सबपर वेब देव
स्रोत

15

यह O(N)जटिलता नहीं हैO(1)

— 17

19

@SubparWebDev नहीं, आप नहीं जानते कि लूप के माध्यम से कितनी बार मिलेगा, भले ही आप कार्यक्रम शुरू करने और निर्दिष्ट तिथि के बीच के समय में सटीक अंतर जानते हों। यह इस बात पर निर्भर है कि कंप्यूटर कितनी तेजी से चल रहा है, इस पर और क्या चल रहा है, सीपीयू कैसे कार्य को निर्धारित करता है, आदि

— Servy

131

@ फैजान ऐसा नहीं है Nकि एल्गोरिथ्म निर्भर है, इसलिए आप वास्तव में यह नहीं कह सकते कि यह एक ओ (एन) एल्गोरिथ्म है।

— सेवित

29

तकनीकी रूप से कोई इनपुट नहीं है, इसलिए Nइसका कोई मतलब भी नहीं है। लेकिन आप DateTime.Nowएक इनपुट पर विचार कर सकते हैं जो परिणाम पर अभी भी निर्भर करता है। यदि आप के लिए एक यथार्थवादी मूल्य ग्रहण कर सकते हैं DateTime.Now, तो हाँ, कार्यक्रम समय की एक निरंतर राशि लूप।

— प्रहार

43

समस्या कथन को परिभाषित करना चाहिए कि N क्या है।

— याकूब मस्साद

406

इस संदर्भ में बिग ओ नोटेशन का उपयोग किसी फ़ंक्शन के इनपुट के आकार और उस इनपुट के परिणाम की गणना करने के लिए किए जाने वाले संचालन की संख्या के बीच संबंध का वर्णन करने के लिए किया जा रहा है।

आपके ऑपरेशन का कोई इनपुट नहीं है कि आउटपुट संबंधित हो सकता है, इसलिए बिग ओ नोटेशन का उपयोग करना निरर्थक है। समय जो ऑपरेशन लेता है वह ऑपरेशन के इनपुट से स्वतंत्र होता है (जो है ... कोई नहीं)। के बाद से वहाँ है इनपुट और संचालन की संख्या प्रदर्शन किया, आप बिग ओ उपयोग नहीं कर सकते बीच कोई रिश्ता नहीं है कि न के बराबर संबंधों का वर्णन करने के लिए

— Servy
स्रोत

6

किस बारे में O(max(1, 2035 - yearTheProgramIsStarted))?

— बरगी

19

@Bergi [वास्तव में नहीं [( stackoverflow.com/questions/34048740/… ), आप केवल उस समय के आधार पर लूप के पुनरावृत्तियों की संख्या का वर्णन नहीं कर सकते हैं जो उस समय पर आधारित हैं जब आप नौकरी चलाते हैं। और निश्चित रूप से आप इस तथ्य के साथ जोड़ते हैं कि सिस्टम घड़ी को उपयोगकर्ता द्वारा किसी भी समय बदला जा सकता है, जो भी समय वे चाहते हैं, आदि और आपके पास अभी भी एक अच्छी तरह से गठित इनपुट नहीं है जो आप की संख्या से संबंधित हो सकते हैं। आउटपुट के उत्पादन के लिए आवश्यक संचालन। हेक, यहां तक कि आउटपुट भी सुसंगत नहीं है।

— सेवाकाल

23

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

— कॉनर क्लार्क

9

अधिक स्पष्ट होने के लिए, 'निहित' इनपुट 1 जनवरी, 2035 और आज के बीच का डेल्टा है।

— कॉनर क्लार्क

6

@Hoten लेकिन सिस्टम का समय निश्चित मूल्य नहीं है। यह फ़ंक्शन इनपुट के रूप में केवल प्रारंभ समय के लिए स्वीकार करने के समान नहीं हैDateTime । जैसा कि मैंने पहले कहा था, सिस्टम घड़ी समय के साथ बदल सकती है । और फिर, आप सीधे quazi इनपुट को मैप नहीं कर सकते हैं जिसे आप निश्चित आउटपुट के लिए बता रहे हैं। दिए गए प्रारंभ समय के लिए किए गए ऑपरेशनों की एक ज्ञात संख्या नहीं है, या यहां तक कि दो कार्यक्रमों के लिए जो हमेशा एक समझदार मूल्य प्राप्त करते हैं DateTime.Now, इसलिए आप दोनों को समय के परिवर्तन के रूप में संबंधित नहीं कर सकते, क्योंकि आप उन्हें भी संबंधित नहीं कर सकते हैं समय नहीं बदलता है।

— सेवाकाल

88

बिग-ओ नोटेशन का मतलब मोटे तौर पर 'काम की मात्रा पर एक ऑपरेशन दिया जाता है, एन, कितना गणना समय, एन के अनुपात में, एल्गोरिदम लेता है?'। जैसे, आकार की एक सरणी N को N ^ 2, Nlog (N), आदि ले सकते हैं।

इस पर कार्य करने के लिए कोई इनपुट डेटा नहीं है। तो यह नहीं है O(anything)।

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

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

यह क्या है, तकनीकी रूप से, एक नियंत्रण प्रणाली है। विकिपीडिया से;

एक नियंत्रण प्रणाली एक उपकरण है, या उपकरणों का सेट है, जो अन्य उपकरणों या प्रणालियों के व्यवहार का प्रबंधन, निर्देश, निर्देशन या विनियमन करता है।

गणितीय कार्यों और एल्गोरिदम के बीच अंतर के बारे में अधिक गहराई से उत्तर चाहने वाले लोगों के लिए, और सांत्वना आउटपुट, ग्राफिक्स प्रदर्शित करने या रोबोट को नियंत्रित करने जैसी चीजों को करने के लिए कंप्यूटर की अधिक शक्तिशाली क्षमता, इस पत्र पर पढ़ा है। मजबूत चर्च-ट्यूरिंग परिकल्पना

सार

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

नए प्रतिमान के रूप में बातचीत की स्वीकृति स्ट्रॉन्ग चर्च-ट्यूरिंग थीसिस (SCT) द्वारा बाधित है, व्यापक विश्वास है कि ट्यूरिंग मशीन (टीएम) सभी कम्प्यूटेशन पर कब्जा कर लेते हैं, इसलिए टीएम की तुलना में गणना के मॉडल अधिक अभिव्यक्त करना असंभव है। इस पत्र में, हम दिखाते हैं कि SCT मूल चर्च-ट्यूरिंग थीसिस (CTT) को इस तरह से पुन: स्थापित करता है, जिसका उद्देश्य कभी नहीं होता; मूल रूप से इसकी सामान्य रूप से मान्यता एक मिथक है। हम SCT में व्यापक विश्वास के ऐतिहासिक कारणों की पहचान और विश्लेषण करते हैं। केवल यह स्वीकार करने से कि यह गलत है कि क्या हम गणना के वैकल्पिक प्रतिमान के रूप में बातचीत को अपनाना शुरू कर सकते हैं

— स्टीव कूपर
स्रोत

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

— बरगी

@ बरगी - हाँ, अपनी बात देखो! बस एक सन्निकटन बना रहा है, वास्तव में, लेकिन हाँ - यदि आप करने के लिए काम की मात्रा को माप सकते हैं, और वहां पहुंचने के लिए जितना कदम उठाते हैं, बिग-ओ उन दो उपायों के संबंध को दर्शाता है। करीब?

— स्टीव कूपर

@kapep - यह एक शुद्ध कार्य नहीं है क्योंकि यह एक शून्य विधि है, लेकिन अगर हम कंसोल आउटपुट की गणना करते हैं, तो यह अभी भी यादृच्छिक है; यह {"हैलो, वर्ल्ड!" के किसी भी आउटपुट कर सकता है, "यह अभी भी हैलो प्रिंट करने का समय नहीं है ... \ n हेलो, वर्ल्ड!", "यह अभी भी हैलो प्रिंट करने का समय नहीं है ... अभी भी प्रिंट करने का समय नहीं है हैलो ... \ n हेल्लो, वर्ल्ड! ", ...}

— स्टीव कूपर 20

1

Stdout में प्रिंट करना आउटपुट नहीं है?

— rpax

4

@rpax गणितीय नहीं, नहीं। एक फ़ंक्शन इनपुट से आउटपुट तक एक अपरिवर्तनीय अनुवाद है; उदाहरण के लिए, 'वर्गाकार' वह फ़ंक्शन है जो हमेशा 9 रिटर्न करता है यदि आप इनपुट करते हैं 3. एक c # विधि केवल एक मैथ्स फ़ंक्शन है यदि एक ही पैरामीटर वाला कॉल हमेशा एक ही रिटर्न मान देता है। अन्यथा - यदि इसके कंसोल पर लिखने, ग्राफिक्स प्रदर्शित करने, मेमोरी आवंटित करने जैसे दुष्प्रभाव हैं - वे गणितीय कार्य नहीं हैं। (मेरे जवाब के लिए एक कड़ी जोड़ें, जो विस्तार से विस्तार में चला जाता है :))

— स्टीव कूपर

41

नहीं, आपके कोड के समय जटिलता है `O(2^|<DeltaTime>|)`,

वर्तमान समय की एक उचित कोडिंग के लिए।
कृपया, मुझे पहले मेरी अंग्रेजी के लिए माफी माँगने दें।

सीएस में बिग ओ क्या काम करता है और कैसे करता है

बिग ओ नोटेशन का उपयोग किसी प्रोग्राम के इनपुट को उसके रनिंग टाइम के साथ टाई करने के लिए नहीं किया जाता है ।
बिग ओ नोटेशन को पीछे छोड़ते हुए, दो मात्राओं के विषम अनुपात को व्यक्त करने का एक तरीका है ।

एल्गोरिथम विश्लेषण के मामले में ये दो मात्राएं इनपुट नहीं हैं (जिसके लिए पहले "माप" फ़ंक्शन होना चाहिए) और चलने का समय।
वे समस्या ^{1 के} उदाहरण के कोडिंग की लंबाई और ब्याज की एक मीट्रिक हैं।

आमतौर पर इस्तेमाल होने वाले मेट्रिक्स होते हैं

गणना के दिए गए मॉडल में एल्गोरिथ्म को पूरा करने के लिए आवश्यक चरणों की संख्या।
गणना के मॉडल द्वारा, यदि कोई ऐसी अवधारणा मौजूद है, तो अंतरिक्ष की आवश्यकता है।

कथित तौर पर एक टीएम को मॉडल के रूप में माना जाता है ताकि पहला बिंदु संक्रमण ² फ़ंक्शन के अनुप्रयोगों की संख्या का अनुवाद करता है , अर्थात "चरण", और दूसरा एक कम से कम एक बार लिखे गए विभिन्न टेप कोशिकाओं की संख्या का अनुवाद करता है ।

क्या यह भी अक्सर माना जाता है कि हम मूल एक के बजाय एक बहुपद से संबंधित एन्कोडिंग का उपयोग कर सकते हैं, उदाहरण के लिए एक फ़ंक्शन जो शुरू से अंत तक एक सरणी की खोज करता है, O(n)इस तथ्य के बावजूद कि इस तरह के सरणी के एक उदाहरण की कोडिंग लंबाई होनी चाहिए। प्रत्येक तत्व के प्रतीकों की (स्थिर) संख्या n*b+(n-1)कहां bहै। ऐसा इसलिए है क्योंकि bगणना मॉडल का एक निरंतर माना जाता है और इसलिए ऊपर की अभिव्यक्ति और nसमान रूप से समान हैं।

यह भी बताता है कि क्यों एक एल्गोरिथ्म जैसे ट्रायल डिवीजन अनिवार्य रूप से एक एल्गोरिथ्म ³ होने के बावजूद एक घातीय एल्गोरिथ्म है ।for(i=2; i<=sqr(N); i++)

देखें इस ।

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

तो यह "इनपुट" के बारे में नहीं है या कि "कोई इनपुट नहीं है"।

अब केस का अध्ययन

बिग ओ नोटेशन आपके एल्गोरिथ्म पर सवाल नहीं उठाता है, यह मानता है कि आप जानते हैं कि आप क्या कर रहे हैं। यह अनिवार्य रूप से एक उपकरण है जो हर जगह लागू होता है, यहां तक कि एल्गोरिथ्म तक जो जानबूझकर मुश्किल हो सकता है (जैसे आपका)।

अपनी समस्या को हल करने के लिए आपने वर्तमान तिथि और भविष्य की तारीख का उपयोग किया है, इसलिए उन्हें किसी तरह समस्या का हिस्सा होना चाहिए; सीधे शब्दों में कहें: वे समस्या के उदाहरण का हिस्सा हैं।

विशेष रूप से उदाहरण है:

<DeltaTime>

जहां <>किसी भी तरह का, गैर-पैथोलॉजिकल, पसंद का कोडिंग होता है।

बहुत महत्वपूर्ण स्पष्टीकरण के लिए नीचे देखें ।

तो आपका बड़ा ओ जटिलता समय बस है O(2^|<DeltaTime>|), क्योंकि आप कई पुनरावृत्ति करते हैं जो वर्तमान समय के मूल्य पर निर्भर करता है। अन्य संख्यात्मक स्थिरांक लगाने का कोई मतलब नहीं है क्योंकि एसिम्प्टोटिक संकेतन उपयोगी है क्योंकि यह स्थिरांक को समाप्त करता है (इसलिए उदाहरण के लिए उपयोग O(10^|<DeltaTime>|*any_time_unit)निरर्थक है)।

जहां मुश्किल हिस्सा है

हमने ऊपर एक महत्वपूर्ण धारणा बनाई: कि गणना का मॉडल ⁵ बार प्रमाण पत्र देता है , और समय के साथ मेरा मतलब है (वास्तविक!) भौतिक समय। मानक कम्प्यूटेशनल मॉडल में ऐसी कोई अवधारणा नहीं है, एक टीएम को समय नहीं पता है, हम समय को चरणों की संख्या के साथ जोड़ते हैं क्योंकि यह हमारी वास्तविकता ^{4 है} ।

हालांकि आपके मॉडल में समय गणना का हिस्सा है, आप यह कहकर कार्यात्मक लोगों की शब्दावली का उपयोग कर सकते हैं कि मेन शुद्ध नहीं है, लेकिन अवधारणा समान है।

इसे समझने के लिए ध्यान रखना चाहिए कि कुछ भी फ्रेमवर्क उस नकली समय का उपयोग करने से नहीं रोकता है जो उस भौतिक समय में दो बार, पांच, दस गुना तेजी से चलता है। इस तरह आपका कोड "आधा", "एक पांचवा", "एक दसवां" "समय" में चलेगा।

यह प्रतिबिंब एन्कोडिंग को चुनने के लिए महत्वपूर्ण है <DeltaTime>, यह अनिवार्य रूप से लेखन का एक घनीभूत तरीका है <(करंट टाइम, टाइमइनफॉवेल)>। चूंकि समय मठ में मौजूद नहीं है, मौजूदा समय की कोडिंग बहुत अच्छी तरह से शब्द हो सकता है अब (या किसी अन्य विकल्प) एक दिन पहले के रूप में कोडित किया जा सकता है कल , वहाँ इस धारणा को तोड़ कर कि कोडिंग की लंबाई वृद्धि शारीरिक समय के रूप में आगे बढ़ता है (और डेल्टाटाइम में से एक घटता है)

हमें कुछ उपयोगी कार्य करने के लिए अपने कम्प्यूटेशनल मॉडल में ठीक से समय देना होगा।

एकमात्र सुरक्षित विकल्प जो हम कर सकते हैं वह है टाइमस्टैम्प्स को बढ़ती हुई लंबाई के साथ सांकेतिक शब्दों में बदलना (लेकिन अभी भी unary का उपयोग नहीं करना) क्योंकि भौतिक समय आगे बढ़ता है। यह उस समय की एकमात्र सच्ची संपत्ति है जिसकी हमें आवश्यकता है और एन्कोडिंग को पकड़ने की आवश्यकता है। क्या यह केवल इस प्रकार के एन्कोडिंग के साथ है कि आपके एल्गोरिथ्म ने शायद एक समय जटिलता दी है।

आपका भ्रम, यदि कोई है, तो इस तथ्य से उत्पन्न होता है कि वाक्यांशों में शब्द का समय 'इसकी समय जटिलता क्या है ?' और 'कितना समय लगेगा?' बहुत अलग चीजों का मतलब है

काश, शब्दावली समान शब्दों का उपयोग करती है, लेकिन आप अपने सिर में "कदम जटिलता" का उपयोग करने की कोशिश कर सकते हैं और अपने आप से अपना प्रश्न पूछ सकते हैं, मुझे आशा है कि आपको उत्तर को समझने में मदद मिलेगी ^ _ ^

¹ यह भी एक स्पर्शोन्मुख दृष्टिकोण की आवश्यकता के रूप में बताता है क्योंकि प्रत्येक उदाहरण में एक अलग है, फिर भी मनमाना नहीं है, लंबाई है।
² मुझे उम्मीद है कि मैं यहाँ सही अंग्रेजी शब्द का उपयोग कर रहा हूँ।
³ इसके अलावा, हम अक्सर log(log(n))गणित में शब्द ढूंढते हैं।
⁴ आईडी एस्ट, एक कदम को कुछ परिमित पर कब्जा करना चाहिए, लेकिन शून्य नहीं, न ही जुड़ा हुआ, समय का अंतराल।
⁵ इसका मतलब यह है कि कम्प्यूटेशनल मोड में भौतिक समय के ज्ञान के रूप में, जो इसे अपनी शर्तों के साथ व्यक्त कर सकता है। एक समानता यह है कि .NET फ्रेमवर्क में जेनरिक कैसे काम करते हैं।

— यूनी एमजे
स्रोत

3

"तो आपका बिग ओ रनिंग टाइम बस है" .. मुझे यकीन है कि आपका मतलब 'बड़ी ओ जटिलता' है। इसके अलावा, हम अभी भी 'डेल्टा' को हमारे 'एन' राइट कह सकते हैं .. इसलिए आपका कहना हे (2 ^ एन) फाइबोनैचि एल्गोरिथ्म की जटिलता जैसा है। आप "2 ^" में कैसे आए?

— रॉस

@Ross, इस बिंदु के लिए धन्यवाद। मैं बाइनरी नंबर के साथ काम करने की आदत से 2 बाहर आया था। मुद्दा यह है कि चरण संख्या के प्रतिनिधित्व की लंबाई के साथ रैखिक हैं । वास्तविक आधार वास्तव में महत्वपूर्ण नहीं है और विशिष्ट एन्कोडिंग के आधार पर भिन्न होता है। यह छद्म रैखिक है ।

— यूनी एमजे

मुझे क्षमा करें, लेकिन क्या आप कृपया अपने उत्तर में अधिक विस्तृत कर सकते हैं कि आपने यह निष्कर्ष निकाला कि जटिलता क्या है O(2^n)? यह शुरुआती लोगों के लिए स्पष्ट नहीं है।

— आर्टुरो टॉरेस सांचेज़

2

@YuniMj जबकि आपका तर्क तकनीकी रूप से गलत नहीं है, मुझे लगता है कि इसके मूल्य के बजाय आकार को मापने के लिए आग्रह करके , आप केवल अतिरिक्त भ्रम जोड़ रहे हैं। उदाहरण के लिए, लेकिन उस कारण से अधिकतम इष्टतम एल्गोरिथ्म में समय जटिलता $ O (n \ cdot log n) $ है। क्यों? क्योंकि आप सॉर्ट करने के लिए या तो केवल कई अलग-अलग वस्तुओं को खरीदते हैं, इस स्थिति में आप हमेशा $ O (n) $ में सॉर्ट करने के लिए बाल्टी सॉर्ट का उपयोग कर सकते हैं। या आपके ऑब्जेक्ट का आकार अनबाउंड है, जिस स्थिति में $ O (n \ cdot log n) $ पकड़ में नहीं आएगा, क्योंकि किसी भी तुलना में लगातार समय नहीं होगा ...DeltaTime

— fgp

1

FWIW O (2 ^ n)! = O (10 ^ n) stackoverflow.com/questions/19081673/…

— नाथन एफडी

29

हालाँकि यहाँ बहुत सारे उत्तर हैं, मुझे उन सभी को थोड़ा सा पुनर्व्यवस्थित करने दें।

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

हम आपके एल्गोरिथ्म को एक स्थिर फ़ंक्शन के रूप में मान सकते हैं जो किसी भी आकार के किसी भी इनपुट को लेता है, इसे अनदेखा करता है, एक निश्चित समय की प्रतीक्षा करता है, और खत्म करता है। इस स्थिति में इसका रनटाइम f (n) = const है , और यह O (1) -टाइम एल्गोरिथम है। यह वही है जो आपने सुनने की उम्मीद की थी, है ना? हां, यह तकनीकी रूप से, एक O (1)-एल्गोरिथम है ।
हम TwentyYearsLaterब्याज के "इनपुट-आकार" के समान पैरामीटर मान सकते हैं । इस स्थिति में रनटाइम f (n) = (nx) है जहां x , आह्वान के समय "अभी समय" है। जब इस तरह से देखा जाता है, तो यह एक ओ (एन)-टाइम एल्गोरिथ्म है। जब भी आप अपने तकनीकी रूप से O (1) -अलगोरिथम अन्य लोगों को दिखाते हैं, तो इस प्रतिवाद की अपेक्षा करें ।
ओह, लेकिन प्रतीक्षा करें, यदि k =TwentyYearsLater इनपुट है, तो इसका आकार n है, वास्तव में, इसे दर्शाने के लिए आवश्यक बिट्स की संख्या, अर्थात n = log (k) । इनपुट n और रनटाइम के आकार के बीच निर्भरता इसलिए f (n) = 2 ^ n - x है । अपने एल्गोरिथ्म की तरह लगता है बस तेजी से धीमा हो गया है! ओह।
कार्यक्रम का एक और इनपुट वास्तव में ओएस द्वारा दिए गए उत्तरों की धाराDateTime.Now को लूप में इनवोकेशन के अनुक्रम में है। हम वास्तव में कल्पना कर सकते हैं कि इस पूरे अनुक्रम को कार्यक्रम चलाने के समय इनपुट के रूप में प्रदान किया गया है। रनटाइम को तब इस अनुक्रम की संपत्ति पर निर्भर माना जा सकता है - अर्थात् पहले TwentyYearsLaterतत्व तक इसकी लंबाई । इस स्थिति में रनटाइम फिर से f (n) = n है और एल्गोरिथ्म O (n) है ।

लेकिन फिर, अपने प्रश्न में, आपने यह भी नहीं कहा कि आप रनटाइम में रुचि रखते थे। क्या होगा अगर आपका मतलब मेमोरी उपयोग से है? इस बात पर निर्भर करते हुए कि आप जिस स्थिति को मॉडल कह सकते हैं, वह यह है कि एल्गोरिथ्म हे (1) -मोरोरी या, शायद, ओ (एन) -Memory (यदि कार्यान्वयन की DateTime.Nowआवश्यकता है तो पूरे मंगलाचरण क्रम का ध्यान रखें।)

और अगर आपका लक्ष्य कुछ बेतुका है, तो आप सभी में क्यों नहीं जाते हैं और कहते हैं कि आप रुचि रखते हैं कि स्क्रीन पर पिक्सेल में एल्गोरिदम के कोड का आकार चुने हुए ज़ूम स्तर पर कैसे निर्भर करता है। यह f (ज़ूम) = 1 / ज़ूम जैसा कुछ हो सकता है और आप गर्व से अपने एल्गोरिथ्म को O (1 / n) -pixel आकार घोषित कर सकते हैं !

— के.टी.।
स्रोत

+1। मेरा मानना है कि "OS द्वारा दिए गए उत्तरों की धारा ' DateTime.Nowइनवोकेशन के अनुक्रम में' वास्तविक इनपुट है। लेकिन मुझे लगता है कि निष्कर्ष यह नहीं होना चाहिए कि यह O (n) है, लेकिन यह O (k) है, जहां k की लंबाई है पहले TwentyYearsLaterतत्व तक ।

— जस्टफुल

7

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

— एंट पी

21

मुझे सर्व के साथ थोड़ा असहमत होना पड़ा। इस कार्यक्रम के लिए एक इनपुट है, भले ही यह स्पष्ट नहीं है, और यह सिस्टम का समय है। यह एक ऐसी तकनीकी हो सकती है जिसका आपने इरादा नहीं किया था, लेकिन आपका TwentyYearsFromNowचर अब सिस्टम के समय से बीस साल नहीं है , यह सांख्यिकीय रूप से 1 जनवरी, 2035 को सौंपा गया है।

इसलिए यदि आप इस कोड को लेते हैं और इसे 1 जनवरी, 1970 के सिस्टम टाइम वाली मशीन पर निष्पादित करते हैं, तो कंप्यूटर को पूरा होने में 65 साल लगने वाले हैं, भले ही कंप्यूटर कितना भी तेज क्यों न हो (इसकी घड़ी दोषपूर्ण होने पर कुछ बदलाव हो सकता है। )। यदि आप इस कोड को लेते हैं और इसे मशीन पर निष्पादित करते हैं जिसमें 2 जनवरी 2035 का सिस्टम समय है, तो यह लगभग तुरंत पूरा हो जाएगा।

मैं कहूंगा कि आपका इनपुट, nहै January 1st, 2035 - DateTime.Now, और यह O (n) है।

फिर संचालन की संख्या का मुद्दा भी है। कुछ लोगों ने उल्लेख किया है कि तेज कंप्यूटर लूप को तेजी से हिट करेगा, जिससे अधिक संचालन होगा, लेकिन यह अप्रासंगिक है। बड़े-ओ संकेतन के साथ काम करते समय, हम प्रोसेसर की गति या संचालन की सटीक संख्या पर विचार नहीं करते हैं। यदि आप इस एल्गोरिथ्म को लेते हैं और इसे कंप्यूटर पर चलाते हैं, और फिर इसे फिर से चलाते हैं, लेकिन उसी कंप्यूटर पर 10x लंबे समय तक, तो आप 10x के समान कारक द्वारा संचालन की संख्या बढ़ने की उम्मीद करेंगे।

इसके लिए:

जब भी कोई व्यक्ति किसी निश्चित जटिलता के एल्गोरिथ्म के लिए पूछता है, तो मैं एक चुटकुला के रूप में डालने के लिए कोड के स्निपेट को एक व्यस्त लूप के रूप में उपयोग करने के बारे में सोच रहा हूं। क्या यह सही होगा?

नहीं वास्तव में नहीं। अन्य उत्तरों ने इसे कवर किया है, इसलिए मैं इसका उल्लेख करना चाहता था। आप आम तौर पर किसी भी बड़े-ओ संकेतन के निष्पादन के वर्षों को सहसंबद्ध नहीं कर सकते। उदाहरण के लिए। निष्पादन के 20 साल = ओ (एन ^ 87) या उस मामले के लिए कुछ और कहने का कोई तरीका नहीं है। यहां तक कि आपके द्वारा दिए गए एल्गोरिदम में, मैं TwentyYearsFromNowवर्ष 20110, 75699436, या 123456789 में बदल सकता था और बिग-ओ अभी भी ओ (एन) है।

— Shaz
स्रोत

7

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

— 20

When working with big-O notation, we don't consider the speed of the processor or the exact number of operations.यह गलत बयान है। बहुत ज्यादा किसी भी समझदार ऑपरेशन को आप बिग ओ मूल्य की गणना करने की कोशिश करेंगे, जो हार्डवेयर के आधार पर किए गए ऑपरेशनों की संख्या को बदलने के लिए नहीं है, लेकिन यह एक करता है । बिग ओ इनपुट के आकार के संचालन की संख्या से संबंधित है। अधिकांश ऑपरेशनों के लिए जो सिस्टम हार्डवेयर से स्वतंत्र है। इस मामले में यह नहीं है ।

— 20

If you took this algorithm and ran it on a computer, and then ran it again but for 10x longer on the same computer, you would expect the number of operations to grow by the same factor of 10x.

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

— सेवाकाल

मैं इस पर @Servy के साथ हूं, लेकिन थोड़े अलग कारण से। मुख्य कार्य कोई पैरामीटर नहीं लेता है और कोई इनपुट नहीं देता है। यदि आप चाहें, तो यह शून्य => शून्य का कार्य है। कोई फर्क नहीं पड़ता कि समय क्या है, यह अभी भी कुछ भी नहीं लौटाता है।

— स्टीव कूपर

1

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

— स्टीव कूपर

13

बिग-ओ विश्लेषण में शामिल प्रसंस्करण की मात्रा से संबंधित है क्योंकि संसाधित किए जा रहे डेटा की मात्रा सीमा के बिना बढ़ जाती है।

यहाँ, आप वास्तव में केवल निश्चित आकार की एक ही वस्तु के साथ काम कर रहे हैं। जैसे, बिग-ओ विश्लेषण लागू करना बहुत हद तक (मुख्य रूप से?) निर्भर करता है कि आप अपनी शर्तों को कैसे परिभाषित करते हैं।

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

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

— जेरी कॉफ़िन
स्रोत

10

big-O क्या के सापेक्ष?

आपको लगता है कि twentyYearsLaterयह एक "इनपुट" है। यदि वास्तव में आपने अपना कार्य लिखा है

void helloWorld(int years) {
   // ...
}

यह O (N) होगा जहां N = वर्ष (या सिर्फ कहते हैं O(years))।

मैं कहूंगा कि आपका एल्गोरिथ्म O (N) के सापेक्ष है जो भी संख्या आप कोड की पंक्ति में लिखना शुरू करते हैं twentyYearsLater =। लेकिन लोग आमतौर पर वास्तविक स्रोत कोड में संख्याओं को इनपुट नहीं मानते हैं। वे इनपुट के रूप में कमांड लाइन इनपुट, या इनपुट के रूप में फ़ंक्शन सिग्नेचर इनपुट पर विचार कर सकते हैं, लेकिन, संभवत: स्रोत कोड ही नहीं। यही कारण है कि आप अपने दोस्त के साथ विवाद कर रहे हैं - क्या यह "इनपुट" है? आप अपने कोड को एक सहज ज्ञान युक्त इनपुट के रूप में बनाने के लिए एक तरह से सेट अप करते हैं, और आप निश्चित रूप से इसके बड़े O को अपने प्रोग्राम के लाइन 6 पर नंबर N के संबंध में पूछ सकते हैं, लेकिन यदि आप इस तरह के गैर-डिफ़ॉल्ट विकल्प का उपयोग करते हैं इनपुट के रूप में आपको वास्तव में इसके बारे में स्पष्ट होना चाहिए।

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

इसी तरह का सवाल - रनटाइम क्या है:

void sortArrayOfSizeTenMillion(int[] array)

यह मानते हुए कि यह क्या कहता है और इनपुट वैध है, और एल्गोरिथ्म एक क्विकॉर्ट्स या बबल सॉर्ट या कुछ भी उचित है, यह ओ (1) है।

— djechlin
स्रोत

इनपुट को हार्डकोड करने का मतलब यह नहीं है कि इनपुट गायब हो गया है। न ही किसी भी उदाहरण में ओ (1) समय जटिलता के क्विकॉर्ट्स और बबलोर्ट हैं। bigocheatsheet.com

— थियो ब्रिंकमैन

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

— djechlin

समान रूप से 'गैर-तकनीकी शब्दों' में, आप प्रश्न में आलंबन का वर्णन निलंबन पुल के रूप में कर सकते हैं।

— थियो ब्रिंकमैन

@ TheoBrinkman नहीं, आप नहीं कर सकते। इससे किसी को कोई मतलब नहीं होगा।

— djechlin

यह ओ (1) बबल सॉर्ट के रूप में वर्णित करने के रूप में हर बिट को बहुत अधिक समझ में आता है।

— थियो ब्रिंकमैन

8

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

कार्यक्रम केवल इनपुट की अनदेखी करता है (जो भी लंबाई का), इसलिए लिया गया समय (या मशीन निर्देशों की संख्या निष्पादित) इनपुट की लंबाई के समान ही है (निश्चित वातावरण = प्रारंभ समय + हार्डवेयर), इसलिए O (1) )।

— waldol1
स्रोत

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

— सर्व करें

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

— Waldol1

Let's suppose that there is a finite lower bound on the amount of time a loop iteration takesवह झूठी धारणा है। कार्यक्रम हमेशा के लिए चल सकता है। मुझे बस इतना करना है कि अपने सिस्टम क्लॉक को अब से 50 साल के लिए सेट करें, इसे शुरू करें, और यह कभी खत्म नहीं होगा। या मैं घड़ी को पीछे की ओर तेजी से आगे बढ़ा सकता था, या इसे अतीत में एक अनिश्चित बिंदु पर शुरू कर सकता था । आप बस यह नहीं मान सकते हैं कि कार्यक्रम कितने समय तक चलता है, इसकी सीमा कम है; यह हमेशा के लिए चल सकता है। लेकिन, भले ही हम आपकी (झूठी) धारणा को सच मान लें, फिर भी आप इनपुट पर किए गए ऑपरेशन की संख्या से संबंधित नहीं हो सकते।

— सर्व करें

एक एकल लूप चलना समय की एक सीमित राशि लेता है। हो सकता है कि अनंत बार इसे अंजाम दिया जाए, लेकिन हर एक को लगभग स्थिर होना चाहिए। मुझे उस धारणा के साथ कोई समस्या नहीं दिख रही है।

— Waldol1

उस [पूरी तरह से गलत] तर्क द्वारा हर एक एल्गोरिथ्म हमेशा O (1) होता है क्योंकि हर व्यक्ति का ऑपरेशन हमेशा स्थिर होता है। आप बस यह प्रदर्शित कर रहे हैं कि आप नहीं जानते कि बिग ओ क्या है। यह (संदर्भ में) इनपुट के आकार के बीच संबंध का वर्णन करने के लिए एक उपकरण है, जो प्रासंगिक संचालन की संख्या है। O (1) का मतलब है कि इनपुट की परवाह किए बिना निरंतर संचालन की संख्या है। यहां इनपुट की परवाह किए बिना निरंतर संचालन की संख्या नहीं है, संभावित रूप से किए गए अनंत ऑपरेशन हैं, अनंत! = स्थिर।

— सेवाकाल

6

एक बात मुझे आश्चर्य है कि अभी तक इसका उल्लेख नहीं किया गया है: बिग-ओ नोटेशन एक ऊपरी बाध्य है!

इस मुद्दे पर सभी ने ध्यान दिया है कि एल्गोरिथ्म में इनपुट का वर्णन करने वाला कोई एन नहीं है, इसलिए इसके साथ बिग-ओ विश्लेषण करने के लिए कुछ भी नहीं है। हालांकि, यह आसानी से कुछ बुनियादी प्रवंचनाओं के साथ कम हो जाता है, जैसे कि int n"हैलो वर्ल्ड" को स्वीकार करना और प्रिंट करना n। यह उस शिकायत के इर्द-गिर्द घूमता है और वास्तविक सवाल पर वापस DateTimeलौटता है कि कैसे राक्षसी काम करती है।

कोई वास्तविक गारंटी नहीं है कि लूप कभी भी समाप्त हो जाएगा। हमें लगता है कि यह कुछ समय के लिए है, लेकिन विचार करें कि सिस्टम की तारीख और समयDateTime.now लौटाता है । वास्तव में इस बात की कोई गारंटी नहीं है कि यह नीरस रूप से बढ़ रहा है। यह संभव है कि कुछ प्रशिक्षित प्रशिक्षित बंदर लगातार सिस्टम की तारीख और समय को बदलकर 21 अक्टूबर, 2015 12:00:00 यूटीसी तक करें जब तक कोई बंदर को कुछ ऑटो-फिटिंग जूते और एक होवरबोर्ड न दे। यह लूप वास्तव में अनंत समय तक चल सकता है!

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

* संपादित करें: केटी के साथ मेरी चर्चा से, यह हमेशा उस परिदृश्य को मान्य करने के लिए मान्य नहीं है जिसे हम बड़े-ओ संकेतन के साथ मॉडलिंग कर रहे हैं, यह सबसे खराब स्थिति है। ज्यादातर मामलों में, यदि कोई व्यक्ति यह निर्दिष्ट करने में विफल रहता है कि हम किस मामले का उपयोग कर रहे हैं, तो उनका इरादा सबसे खराब मामले का पता लगाने का था। हालांकि, आप सर्वश्रेष्ठ-केस रनटाइम पर एक बड़े-ओ जटिलता विश्लेषण कर सकते हैं।

— Cort Ammon
स्रोत

2

हे, एक अर्थ में "ऊपरी बाध्य" है, लेकिन इसका मतलब यह नहीं है कि आप केवल ओ-नोटेशन का उपयोग करके "सबसे खराब स्थिति" की बात कर सकते हैं। अपेक्षित जटिलता, सर्वश्रेष्ठ-मामले की जटिलता, किसी भी अन्य कार्यात्मक संपत्ति - इन सभी की चर्चा उनके O सीमा के संदर्भ में की जा सकती है।

— केटी।

@ सबसे अच्छी स्थिति जटिलता को ओ-ओ कहा जाता है, और अपेक्षित जटिलता बड़ी थीटा है। बिग-ओ हमेशा सबसे खराब स्थिति जटिलता है, इसकी गणितीय परिभाषा के अनुसार।

— Cort Ammon

नहीं, आप यहाँ गलत हैं। परिभाषाओं की फिर से जाँच करें।

— केटी।

@ टीके ठीक है, मैं उन्हें रीचेक करूंगा। आप उन्हें भी याद करते हैं। en.wikipedia.org/wiki/Big_O_not इसकी Bachmann-Landau अंकन के परिवार के तहत

— Cort Ammon

मुझे लगता है कि आप कुछ पागल कर सकते हैं जैसे कि एक फ़ंक्शन लें fऔर फ़ंक्शन gको उसी के रूप में घोषित करें f, लेकिन केवल एक सीमित डोमेन के साथ fसबसे अच्छा मामला शामिल है, और फिर बड़े-ओह करते हैं g, लेकिन यह तब होता है जब आप करते हैं। उस।

— Cort Ammon

5

जटिलता का उपयोग समय / स्थान के संदर्भ में कम्प्यूटेशनल "हॉर्सपावर" को मापने के लिए किया जाता है। बिग ओ नोटेशन का उपयोग तुलना करने के लिए किया जाता है कि कौन सी समस्याएं "कम्प्यूटेबल" हैं या "कम्प्यूटेबल नहीं हैं" और यह भी तुलना करने के लिए कि कौन से समाधान-एल्गोरिथम- अन्य की तुलना में बेहतर हैं। जैसे, आप किसी भी एल्गोरिथ्म को दो श्रेणियों में विभाजित कर सकते हैं: जिन्हें बहुपद में हल किया जा सकता है और जो नहीं कर सकते।

Erathostene की छलनी जैसी समस्याएं O (n ^ exp) हैं और इस प्रकार n के छोटे मानों के लिए हल हैं। वे कम्प्यूटेशनल हैं, बस बहुपद समय (एनपी) में नहीं हैं और इस प्रकार जब पूछा गया कि क्या कोई संख्या प्रधान है या नहीं, तो उत्तर इस तरह की संख्या के परिमाण पर निर्भर करता है । इसके अलावा, जटिलता हार्डवेयर पर निर्भर नहीं करती है, इसलिए तेज कंप्यूटर होने से कुछ भी नहीं बदलता है ...

हैलो वर्ल्ड एक एल्गोरिथ्म नहीं है और जैसा कि इसकी जटिलता को निर्धारित करने का प्रयास करने के लिए बेहूदा है, जो कोई नहीं है। एक सरल एल्गोरिथ्म कुछ इस तरह हो सकता है: एक यादृच्छिक संख्या दी गई है, यह निर्धारित करें कि यह सम या विषम है। अब, क्या यह मायने रखता है कि दी गई संख्या में 500 अंक हैं? नहीं, क्योंकि आपको केवल यह जांचना है कि अंतिम अंक सम या विषम है या नहीं। एक अधिक जटिल एल्गोरिदम यह निर्धारित करने के लिए होगा कि क्या दी गई संख्या 3 से समान रूप से विभाजित होती है। हालांकि कुछ संख्याओं की गणना करने के लिए "आसान" हैं, अन्य "कठिन" हैं और यह इसकी परिमाण के कारण है: रिमाइंडर के बीच का निर्धारण करने में लगने वाले समय की तुलना करें 500 अंकों के साथ एक अंक और अन्य के साथ एक संख्या।

एक पाठ को डिकोड करने के लिए एक अधिक जटिल मामला होगा। आपके पास प्रतीकों का एक स्पष्ट यादृच्छिक सरणी है जो आप भी जानते हैं कि डिक्रिप्टिंग कुंजी वाले लोगों के लिए एक संदेश बता रहे हैं। मान लीजिए कि प्रेषक ने बाईं ओर की कुंजी का उपयोग किया है और आपकी हैलो वर्ल्ड पढ़ी जाएगी: Gwkki Qieks। "बिग-हैमर, नो-ब्रेन" सॉल्यूशन उन अक्षरों के लिए सभी संयोजनों का उत्पादन करेगा: आआआ से ज़ज्ज़ तक और फिर एक शब्द शब्दकोश खोजें, जो यह पहचानने के लिए कि कौन से शब्द मान्य हैं और दो सामान्य अक्षरों को सायफ़र (i, k) में साझा करें एक ही स्थिति। यह परिवर्तन समारोह क्या बिग हे उपाय है!

— ट्यूरिंग
स्रोत

4

अधिकांश लोगों को दो बहुत महत्वपूर्ण चीजें याद आ रही हैं।

कार्यक्रम करता है एक इनपुट है। यह हार्ड-कोडित तारीख / समय है जिसके खिलाफ सिस्टम समय की तुलना की जा रही है। एल्गोरिदम चलाने वाले व्यक्ति के नियंत्रण में हैं, और सिस्टम का समय नहीं है। इस कार्यक्रम को चलाने वाले व्यक्ति को नियंत्रित करने की तारीख / समय की तुलना में हार्ड-कोडेड है।
कार्यक्रम इनपुट मूल्य के आधार पर भिन्न होता है , लेकिन इनपुट सेट का आकार नहीं होता है, जो कि बड़े-ओ संकेतन के साथ संबंध है।

इसलिए, यह अनिश्चित है, और इस कार्यक्रम के लिए सबसे अच्छा 'बिग-ओ' संकेतन शायद ओ (अशक्त), या संभवतः ओ (NaN) होगा।

— थियो ब्रिंकमैन
स्रोत

1

(२) फ्लैट-आउट गलत है। आमतौर पर "इनपुट की लंबाई" माना जाता है। निश्चित-आकार की वस्तुओं की सूची या सरणी (पूर्णांक की तरह) के लिए यह वास्तव में सेट का आकार होगा। 1395195191600333 जैसी संख्या को कारक करने के लिए इसके बाइनरी (या दशमलव, आदि) प्रतिनिधित्व यानी अंकों की संख्या होगी। जैसा कि (2) में आपकी परिभाषा में कहा गया है कि "findPrimeFactors (int num)" की जटिलता पर चर्चा करने के लिए बड़े-O का उपयोग करना प्रतिबंधित है, जिस पर अधिकांश क्रिप्टोग्राफर को आपत्ति होगी।

— djechlin

4

सभी ने सही ढंग से बताया कि आप एन को परिभाषित नहीं करते हैं , लेकिन इसका जवाब सबसे उचित व्याख्या के तहत नहीं है। यदि N स्ट्रिंग की लंबाई है जिसे हम प्रिंट कर रहे हैं और "हैलो, वर्ल्ड!" केवल एक उदाहरण है, जैसा कि हम इसके लिए एक एल्गोरिथ्म के रूप में वर्णन कर सकते हैं "के लिए hello, world!," तो एल्गोरिथ्म हे ( एन ) है, क्योंकि आपके पास प्रिंट करने के लिए तीस, चालीस या पचास साल लगने वाले आउटपुट स्ट्रिंग हो सकते हैं, और आप 'केवल एक निरंतर समय जोड़ना है। O ( kN + c ) (O ( N )।

परिशिष्ट:

मेरे आश्चर्य करने के लिए, कोई इस पर विवाद कर रहा है। बड़े ओ और बड़े Rec की परिभाषाओं को याद करें। मान लें कि हमारे पास एक एल्गोरिथ्म है जो निरंतर समय सी की प्रतीक्षा करता है और फिर रैखिक एन में लंबाई एन का संदेश प्रिंट करता है। (यह मूल कोड नमूने का एक सामान्यीकरण है।) आइए मनमाने ढंग से कहें कि हम मुद्रण शुरू करने के लिए बीस साल इंतजार करते हैं, और यह कि ट्रिलियन अक्षरों को प्रिंट करने में एक और बीस साल लगते हैं। चलो ग = 20 और कश्मीर = 10¹², उदाहरण के लिए, लेकिन किसी भी सकारात्मक वास्तविक संख्या क्या करेंगे। यह प्रति वर्ण d = c / k (इस मामले में 2 × 10 character) वर्षों की दर है, इसलिए हमारा निष्पादन समय f ( N ) asymptotically हैdN + c साल। जब भी एन > के , डीएन = सी / के एन > सी । इसलिए, dN < dN + c = f ( N ) <2 dN for सभी N > k , और f ( N ) d) ( N )। QED

— Davislor
स्रोत

जहाँ हमारे पास N = 13.

— djechlin

लेकिन यह सिर्फ "हैलो वर्ल्ड" नहीं छापता है, यह "यह अभी भी समय नहीं है" लाइनों की एक अज्ञात संख्या को प्रिंट करता है। इसके अतिरिक्त, बिग ओ का उपयोग वास्तव में इनपुट के आकार को आउटपुट के आकार से तुलना करने के लिए नहीं किया जाता है, यह आमतौर पर इनपुट के आकार की तुलना ऑपरेशन की संख्या, या उपयोग की जाने वाली मेमोरी की मात्रा से की जाती है।

— सर्व करें

@ सरवी यह निरंतर मेमोरी है, लेकिन मैं निष्कासन के समय निष्पादन को बाध्य कर रहा था। आउटपुट का आकार ओ ( एन ) भी है, एक मनमाना स्ट्रिंग के लिए: हम जिस समय को प्रिंट करते हैं, वह कृपया मनमाने ढंग से बड़ा हो सकता है, यहां तक कि कृपया बीस-वर्षीय संदेशों की तुलना में।

— डेविस्लर

@ Servy मैंने यह स्पष्ट करने के लिए संपादन किया है कि, नहीं, N यहाँ आउटपुट का आकार नहीं है। मुझे यकीन नहीं है कि मैंने यह धारणा कैसे दी, लेकिन मैं किसी भी अस्पष्टता को हटा दूंगा।

— डेविस्लर

1

इसलिए यदि आप मानते हैं कि प्रोग्राम एक इनपुट लेता है, जब यह नहीं होता है, कि आउटपुट मनमाने ढंग से बड़ा हो सकता है, जब यह नहीं हो सकता है, कि लूप कुछ भी नहीं करता है, जब यह करता है, और यह कि आउटपुट संबंधित है इनपुट, जब यह नहीं है, तो हाँ, प्रोग्राम रैखिक है। बेशक, उन मान्यताओं में से हर एक पूरी तरह से गलत है, इसलिए आपने जो निष्कर्ष निकाला है वह पकड़ में नहीं आता है। यदि आप गलत अनुमान लगाए बिना अपनी बात प्रदर्शित करने में सक्षम हैं, तो इसका मतलब कुछ होगा।

— सेवई

4

मुझे लगता है कि लोगों को फेंक दिया जा रहा है क्योंकि कोड एक पारंपरिक एल्गोरिथ्म की तरह नहीं दिखता है। यहाँ उस कोड का अनुवाद किया गया है जो अधिक सुव्यवस्थित है, लेकिन ओपी के प्रश्न की भावना के लिए सही है।

void TrolloWorld(long currentUnixTime, long loopsPerMs){
    long laterUnixTime = 2051222400000;  //unix time of 01/01/2035, 00:00:00
    long numLoops = (laterUnixTime-currentUnixTime)*loopsPerMs;

    for (long i=0; i<numLoops; i++){
        print ("It's still not time to print the hello …");
    }
    print("Hello, World!");
}

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

उन सीमाओं के कारण जो हम प्रदान कर सकते हैं इनपुट पर लगाए गए हैं, ऑपरेशन की संख्या के लिए एक ऊपरी बाध्य है जिसे निष्पादित किया जाएगा, इसलिए यह एल्गोरिथम वास्तव में ओ (1) है।

— नाथन एफडी
स्रोत

2

इस समय, हाँ

इस एल्गोरिथ्म में एक निहित इनपुट है, अर्थात् उस समय जब प्रोग्राम शुरू किया जाता है। निष्पादन का समय रेखीय रूप से ^{1 के} आधार पर अलग-अलग होगा जब यह शुरू किया जाता है। वर्ष 2035 के दौरान और उसके बाद, जबकि लूप तुरंत बाहर निकल जाता है और कार्यक्रम निरंतर संचालन ^{2 के} बाद समाप्त हो जाता है । तो यह कहा जा सकता है कि रनटाइम O(max(2035 - start year, 1))^{3 है} । लेकिन चूंकि हमारे प्रारंभ वर्ष का एक न्यूनतम मूल्य है, एल्गोरिथ्म को निष्पादित करने में 20 साल से अधिक का समय नहीं लगेगा (अर्थात एक स्थिर मूल्य)।

आप ⁴ को परिभाषित करके अपने इरादे को ध्यान में रखते हुए अपने एल्गोरिथ्म को और अधिक बना सकते हैंDateTime TwentyYearsLater = DateTime.Now + new TimeSpan(365*20,0,0,0);

¹ यह संचालन की संख्या के रूप में मापी गई निष्पादन समय की अधिक तकनीकी समझ के लिए है, क्योंकि प्रति यूनिट यूनिट की अधिकतम संख्या है।
² मान DateTime.Nowलेना एक निरंतर ऑपरेशन है, जो उचित है।
³ मैं यहाँ कुछ बड़े ओ नोटेशन का दुरुपयोग कर रहा हूँ क्योंकि यह सम्मान के साथ घटता कार्य है start year, लेकिन हम इसे आसानी से सुधार सकते हैं years prior to 2035।
⁴ फिर एल्गोरिथ्म अब प्रारंभ समय के निहित इनपुट पर निर्भर करता है, लेकिन इसका कोई परिणाम नहीं होता है।

— नाथन एफडी
स्रोत

1

मेरा तर्क है कि यह O (n) है। एक संदर्भ के रूप में http://www.cforcoding.com/2009/07/plain-english-explanation-of-big-o.html का उपयोग करना ।

बिग ओ क्या है?

बिग ओ नोटेशन एक महत्वपूर्ण एल्गोरिथ्म के सापेक्ष जटिलता का वर्णन करना चाहता है जब प्रमुख कारक अनंतता को झुकाते हैं।

तथा

बिग-ओ का सबसे अच्छा उदाहरण मैं सोच सकता हूं कि वह अंकगणित कर रहा है। बुनियादी अंकगणितीय ऑपरेशन जो हमने स्कूल में सीखे:

इसके अलावा, घटाव; गुणन; और विभाजन। इनमें से प्रत्येक एक ऑपरेशन या एक समस्या है। इन्हें हल करने की एक विधि को एक एल्गोरिथ्म कहा जाता है।

आपके उदाहरण के लिए,

n = 20 (यूनिट वर्षों के साथ) का इनपुट दिया गया।

एल्गोरिथ्म एक गणितीय फ़ंक्शन f () है। जहां f () n वर्षों के लिए प्रतीक्षा करने के लिए होता है, बीच में 'डिबग' तार के साथ। स्केल फैक्टर 1. f () इस स्केल फैक्टर को बदलकर घटाया या बढ़ाया जा सकता है।

इस स्थिति के लिए, आउटपुट भी 20 है (इनपुट में परिवर्तन को रेखीय रूप से बदलता है)।

अनिवार्य रूप से कार्य है

f(n) = n*1 = n
    if  n = 20, then 
f(20) = 20

— एंजल कोह
स्रोत

क्या यह तकनीकी रूप से "हैलो वर्ल्ड" के लिए एक ओ (1) एल्गोरिथ्म है?

नहीं, आपके कोड के समय जटिलता है O(2^|<DeltaTime>|),

सीएस में बिग ओ क्या काम करता है और कैसे करता है

अब केस का अध्ययन

जहां मुश्किल हिस्सा है

परिशिष्ट:

इस समय, हाँ

नहीं, आपके कोड के समय जटिलता है `O(2^|<DeltaTime>|)`,