एक अनंत सूची से 100 उच्चतम नंबर प्राप्त करें

Question

मेरे एक मित्र से यह साक्षात्कार प्रश्न पूछा गया था -

"संख्याओं का एक निरंतर प्रवाह होता है, जिसमें कुछ संख्याओं की अनंत सूची होती है, जिसमें से किसी भी समय आप शीर्ष 100 उच्चतम संख्याओं को वापस करने के लिए डेटास्ट्रक्चर को बनाए रखने की आवश्यकता होती है। मान लें कि सभी संख्याएँ पूर्ण संख्याएँ ही हैं।"

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

फिर सवाल बढ़ाया गया -

"क्या आप यह सुनिश्चित कर सकते हैं कि प्रविष्टि के लिए आदेश ओ (1) होना चाहिए? क्या यह संभव है?"

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

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

Comments

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

— एडोडोडो

@EdoDodo - और उस ऑपरेशन के बाद, आपको कैसे पता चलेगा कि सबसे नई संख्या क्या है?

— Damien_The_Unbeliever 8

सूची को क्रमबद्ध करें [O (100 * लॉग (100)) = O (1)] या इसके माध्यम से एक रेखीय खोज करें न्यूनतम [O (100) = O (1)] के लिए नई सबसे कम संख्या प्राप्त करें। आपकी सूची एक स्थिर आकार है, इसलिए इन सभी कार्यों का भी निरंतर समय है।

— रैंडम 832

आपको पूरी सूची को क्रमबद्ध नहीं रखना है। आपको परवाह नहीं है कि उच्चतम या दूसरी-उच्चतम संख्या क्या है। आपको बस यह जानने की जरूरत है कि सबसे कम क्या है। इसलिए जब आप एक नया नंबर डालते हैं, तो आप केवल 100 नंबरों को पीछे छोड़ते हैं और देखते हैं कि अब कौन सा सबसे कम है वह निरंतर समय है।

— टॉम ज़िक

Asymptotic एक ऑपरेशन के आदेश केवल रोचक है जब समस्या का आकार बाध्य के बिना विकसित कर सकते हैं। यह आपके प्रश्न से बहुत अस्पष्ट है कि कौन सी मात्रा बिना बाउंड के बढ़ रही है; ऐसा लगता है कि आप पूछ रहे हैं कि असममित आदेश एक समस्या के लिए है जिसका आकार 100 पर बंधा है; यह पूछने के लिए एक समझदार सवाल भी नहीं है; बिना बँधे कुछ बढ़ाना पड़ता है। यदि प्रश्न है कि क्या आप इसे ओ (1) समय में शीर्ष n, शीर्ष 100 नहीं, के लिए रख सकते हैं? तब सवाल समझदार है।

— एरिक लिपर्ट

Answer 1

मान लीजिए कि k वह उच्चतम संख्या है जिसे आप जानना चाहते हैं (आपके उदाहरण में 100)। फिर, आप एक नया नंबर जोड़ सकते हैं O(k)जिसमें यह भी है O(1)। क्योंकि O(k*g) = O(g) if k is not zero and constant।

Comments

O (50) O (n) है, O (1) नहीं। O (1) समय में लंबाई N की सूची में सम्मिलित करने का अर्थ है कि समय N के मान पर निर्भर नहीं करता है। इसका मतलब है कि यदि 100 10000 हो जाता है, तो 50 को 5000 नहीं होना चाहिए।

@hamstergene - लेकिन इस प्रश्न के मामले में, Nसॉर्ट की गई सूची का आकार, या अब तक संसाधित किए गए आइटमों की संख्या है? यदि आप 10000 आइटम संसाधित करते हैं, और किसी सूची में शीर्ष 100 आइटम रखते हैं, या आप 1000000000 आइटम संसाधित करते हैं, और शीर्ष 100 आइटम को क्रमबद्ध सूची में रखते हैं, तो उस सूची में प्रविष्टि लागत समान रहती है।

— डेमियन___बेलिवर ६

@hamstergene: उस मामले में आपको मूल बातें गलत लगीं। आपकी विकिपीडिया लिंक में एक संपत्ति है ("एक स्थिर से गुणा") O(k*g) = O(g) if k not zero and constant:। => O(50*1) = O(1)।

— duedl0r

मुझे लगता है कि duedl0r सही है। आइए समस्या को कम करें और कहें कि आपको केवल न्यूनतम और अधिकतम मूल्यों की आवश्यकता है। क्या यह O (n) है क्योंकि minumum और अधिकतम 2 हैं? (एन = 2)। नंबर 2 समस्या की परिभाषा का हिस्सा है। एक स्थिर है, इसलिए यह O (k * कुछ) में ak है जो O (कुछ) के बराबर है

— xanatos

@hamstergene: आप किस फंक्शन की बात कर रहे हैं? मान 100 मुझे बहुत स्थिर लगता है ..

— duedl0r

Answer 2

सूची को अनसुलझा रखें। यह पता लगाना कि नया नंबर डालने में ज्यादा समय लगेगा या नहीं, लेकिन प्रविष्टि O (1) होगी।

Comments

मुझे लगता है कि यह आपको स्मार्ट-एलेक पुरस्कार मिलेगा अगर कुछ और नहीं। * 8 ')

— मार्क बूथ

@ ईमिलियो, आप तकनीकी रूप से सही हैं - और निश्चित रूप से यह सबसे सही प्रकार है ...

— गैरेथ

लेकिन आप अपने 100 नंबरों में से सबसे कम भी रख सकते हैं, फिर आप यह भी तय कर सकते हैं कि आपको ओ (1) में सम्मिलित करने की आवश्यकता है या नहीं। फिर केवल जब आप एक नंबर डालते हैं, तो क्या आपको नया सबसे कम नंबर खोजना होगा। लेकिन ऐसा होता है कि डालने या न तय करने की तुलना में दुर्लभ, जो हर नए नंबर के लिए होता है।

— आंद्रेई वजना II

Answer 3

यह आसान है। स्थिर की सूची का आकार, इसलिए सूची का क्रम समय स्थिर है। एक ऑपरेशन जो निरंतर समय में निष्पादित होता है, उसे ओ (1) कहा जाता है। इसलिए सूची को निश्चित आकार की सूची के लिए O (1) क्रमबद्ध करना है।

Answer 4

एक बार जब आप 100 नंबर पास कर लेते हैं, तो अगली संख्या के लिए आप जिस अधिकतम लागत को कभी भी उठा सकते हैं, वह यह जांचने की लागत है कि क्या नंबर 100 नंबर में है (चलो चेकटाइम लेबल करें ) और साथ ही उस सेट में प्रवेश करने की लागत और अस्वीकार करें सबसे कम एक (जिसे कॉल करते हैं EnterTime ), जो निरंतर समय (कम से कम बाध्य संख्याओं के लिए), या O (1) है ।

Worst = CheckTime + EnterTime

अगला, यदि संख्याओं का वितरण यादृच्छिक है, तो औसत लागत आपके पास अधिक संख्या घट जाती है। उदाहरण के लिए, आपको 101 सेट में अधिकतम संख्या 100/101 में दर्ज करने का मौका मिलेगा, 1000 वें नंबर के लिए संभावना 1/10 होगी, और nth संख्या के लिए संभावना 100 / n होगी। इस प्रकार, औसत लागत के लिए हमारा समीकरण होगा:

Average = CheckTime + EnterTime / n

इस प्रकार, n के रूप में अनन्तता आती है, केवल CheckTime महत्वपूर्ण है:

Average = CheckTime

यदि संख्याएं बाध्य हैं, तो चेकटाइम स्थिर है, और इस प्रकार यह ओ (1) समय है।

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

मैं सकारात्मक नहीं हूं, लेकिन मेरी आंत कहती है कि यह ओ (लॉग (एन (एन))) समय है। ऐसा इसलिए है क्योंकि मौका है कि सबसे कम संख्या बढ़ रही है लघुगणक, और मौका है कि बिट्स की संख्या आप प्रत्येक चेक के लिए विचार करने की जरूरत है लघुगणक भी है। मैं अन्य लोगों में दिलचस्पी लेता हूं, क्योंकि मैं वास्तव में निश्चित नहीं हूं ...

Comments

सिवाय इसके कि सूची मनमानी है, क्या होगा यदि यह लगातार बढ़ती संख्याओं की सूची है?

— dan_waterworth

@ डान_ वाटरवर्थ: यदि अनंत सूची अस्वाभाविक है और बस हमेशा की वृद्धि होती है (जिसका अंतर 1 / be होगा!), जो CheckTime + EnterTimeप्रत्येक संख्या के लिए सबसे खराब स्थिति में फिट होगा । यह केवल तभी समझ में आता है जब संख्याएँ अनबाउंड होती हैं, और इसलिए CheckTimeऔर EnterTimeदोनों संख्याओं के आकार में वृद्धि के कारण कम से कम लघुगणक में वृद्धि करेंगे।

— ब्रिग्य 3737 19

संख्याएं यादृच्छिक नहीं हैं, मनमाने हैं। यह बाधाओं के बारे में बात करने के लिए कोई मतलब नहीं है।

— dan_waterworth

@dan_waterworth: आपने दो बार कहा है कि संख्याएँ मनमानी हैं। आप यह कहाँ से प्राप्त कर रहे हैं? इसके अलावा, मेरा मानना ​​है कि आप अभी भी यादृच्छिक मामले से शुरू होने वाली मनमानी संख्याओं पर आँकड़े लागू कर सकते हैं, और उनकी सटीकता में सुधार कर सकते हैं जैसा कि आप मध्यस्थ के बारे में अधिक जानते हैं। उदाहरण के लिए, यदि आप मध्यस्थ थे, तो ऐसा प्रतीत होता है कि बढ़ती संख्या का चयन करने की अधिक संभावना होगी यदि, कहो, मैं मध्यस्थ था;)

— Briguy37

Answer 5

यह एक आसान है यदि आप बाइनरी हीप पेड़ों को जानते हैं । बाइनरी हीप्स औसत निरंतर समय, ओ (1) में सम्मिलन का समर्थन करते हैं। और आपको पहले एक्स एलिमेंट्स तक आसान पहुंच प्रदान करते हैं।

Comments

उन तत्वों को क्यों संग्रहीत करें जिनकी आपको आवश्यकता नहीं है? (मान जो बहुत कम हैं) एक कस्टम एल्गोरिथ्म की तरह लगता है अधिक उपयुक्त है। यह कहते हुए कि आप मूल्यों को 'जोड़ नहीं सकते' जब वे निम्नतम से अधिक नहीं होते हैं।

— स्टीवन ज्यूरिस

मुझे नहीं पता, मेरा अंतर्ज्ञान मुझे बताता है कि एक ढेर (कुछ स्वाद का) इसे अच्छी तरह से खींच सकता है। इसका मतलब यह नहीं है कि वह ऐसा करने के लिए सभी तत्वों को रखना होगा। मैंने इस पर शोध नहीं किया लेकिन यह "सही लगता है" (टीएम)।

— रिग

एक ढेर को कुछ mth स्तर (बाइनरी हीप्स के लिए और k = 100, m 7 होगा, नोड्स = 2 ^ m-1 के बाद से) के नीचे कुछ भी छोड़ने के लिए संशोधित किया जा सकता है। यह इसे धीमा कर देगा, लेकिन यह अभी भी लगातार समय परिशोधन किया जाएगा।

— प्लूटोर

यदि आपने एक बाइनरी मिन-हीप का उपयोग किया है (क्योंकि तब शीर्ष न्यूनतम है, जिसे आप हर समय जांच रहे हैं) और आपको एक नया नंबर> मिनट मिलता है, तो आपको नया तत्व डालने से पहले शीर्ष तत्व को निकालना होगा । शीर्ष (न्यूनतम) तत्व को हटाना O (logN) होगा क्योंकि आपको पेड़ के हर स्तर को एक बार पार करना होगा। तो यह केवल तकनीकी रूप से सच है कि आवेषण औसत O (1) हैं क्योंकि व्यवहार में यह अभी भी O (logN) है जब भी आपको नंबर 1 मिनट मिलता है।

— स्कॉट व्हिटलॉक

@Plutor, आप कुछ गारंटी दे रहे हैं जो बाइनरी ढेर आपको नहीं देते हैं। इसे बाइनरी ट्री के रूप में कल्पना करते हुए, यह मामला हो सकता है कि बाईं शाखा में प्रत्येक तत्व सही शाखा में किसी भी तत्व से छोटा है, लेकिन आप मान रहे हैं कि सबसे छोटे तत्व जड़ के सबसे करीब हैं।

— पीटर टेलर

Answer 6

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

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

क्योंकि एल्गोरिथ्म जटिलता पर सवाल करना केवल तभी समझ में आता है जब इनपुट का आकार अनिश्चित काल तक बढ़ता है, और एकमात्र इनपुट जो यहां बढ़ सकता है वह 100 है - सूची का आकार; मुझे लगता है कि असली सवाल यह था कि "क्या हम यह सुनिश्चित कर सकते हैं कि हम टॉप एन खर्च ओ (1) समय प्रति नंबर (अपने दोस्त के समाधान में ओ (एन) नहीं) के रूप में प्राप्त करें, क्या यह संभव है?"।

पहली चीज़ जो मन में आती है, वह गिनती की तरह होती है, जो O (m) स्पेस का उपयोग करने की कीमत के लिए Top-N-problem के लिए प्रति नंबर O (1) समय की जटिलता खरीदेगी, जहाँ m आने वाली संख्या की सीमा की लंबाई है । तो हाँ, यह संभव है।

Answer 7

एक फिबोनाची ढेर के साथ कार्यान्वित एक न्यूनतम प्राथमिकता वाली कतार का उपयोग करें , जिसमें निरंतर सम्मिलन का समय होता है:

1. Insert first 100 elements into PQ
2. loop forever
       n = getNextNumber();
       if n > PQ.findMin() then
           PQ.deleteMin()
           PQ.insert(n)

Comments

" O(log n)परिचालित समय में न्यूनतम कार्य के संचालन को हटाएं और हटाएं " , इसलिए यह अभी भी परिणाम देगा कि स्टोर करने के लिए मदों की मात्रा O(log k)कहां kहै।

— स्टीवन ज्यूरिस

यह एमिलियो के जवाब से अलग नहीं है, जिसे ओ (लॉग एन) (विकिपीडिया के अनुसार ) में डिलीट मिनट संचालित होने के बाद से "स्मार्ट-एलेक अवार्ड" मिला ।

— निकोल

@ रेनेसिस एमिलियो का जवाब होगा ओ (के) न्यूनतम खोजने के लिए, मेरा है ओ (लॉग के)

— गैब मुथरार्ट

@ गाबे मेला काफी, मैं सिर्फ सिद्धांत में मतलब है। दूसरे शब्दों में, यदि आप एक स्थिर होने के लिए 100 नहीं लेते हैं, तो यह उत्तर या तो आकस्मिक समय नहीं है।

— निकोल

@ उत्तर मैंने (गलत) कथन को उत्तर से हटा दिया है।

— गाबे मुथरत

Answer 8

कार्य स्पष्ट रूप से एक एल्गोरिथ्म को खोजने के लिए है जो संख्याओं की आवश्यक सूची की लंबाई एन में ओ (1) है। इसलिए इससे कोई फर्क नहीं पड़ता कि आपको शीर्ष 100 नंबर या 10000 नंबर की आवश्यकता है, प्रविष्टि का समय ओ (1) होना चाहिए।

यहाँ ट्रिक यह है कि हालांकि ओ (1) आवश्यकता को सूची सम्मिलित करने के लिए उल्लेख किया गया है, इस सवाल ने पूरे नंबर स्थान में खोज समय के क्रम के बारे में कुछ नहीं कहा, लेकिन यह निकला कि इसे O (1) बनाया जा सकता है। भी। समाधान इस प्रकार है:

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

2. रैंडम स्ट्रीम से नया नंबर x लें।

3. क्या यह पिछले दर्ज की गई सबसे कम संख्या से अधिक है? हां => चरण 4, नहीं => चरण 2

4. बस ली गई संख्या के साथ हैश तालिका मारो। क्या कोई प्रविष्टि है? हां => चरण 5। नहीं => एक नया नंबर x-1 लें और इस चरण को दोहराएं (यह एक सरल नीचे की ओर रैखिक खोज है, बस यहां मेरे साथ रहें, इससे सुधार किया जा सकता है और मैं समझाऊंगा कि कैसे)

5. बस हैश टेबल से प्राप्त सूची तत्व के साथ, लिंक की गई सूची में तत्व के बाद नया नंबर डालें (और हैश को अपडेट करें)

6. दर्ज की गई सबसे कम संख्या को लें (और इसे हैश / सूची से हटा दें)।

7. बस ली गई संख्या के साथ हैश तालिका मारो। क्या कोई प्रविष्टि है? हां => चरण 8. नहीं => एक नया नंबर l + 1 लें और इस चरण को दोहराएं (यह एक सरल उर्ध्व रेखीय खोज है)

8. एक सकारात्मक हिट के साथ यह संख्या सबसे नई संख्या बन जाती है। चरण 2 पर जाएं

डुप्लिकेट मान के लिए अनुमति देने के लिए हैश को वास्तव में डुप्लिकेट वाले तत्वों की लिंक की गई सूची के प्रारंभ और अंत को बनाए रखने की आवश्यकता होती है। दी गई कुंजी पर एक तत्व जोड़ना या हटाना इस प्रकार इंगित की गई सीमा को बढ़ाता या घटाता है।

यहाँ सम्मिलित हे (1) है। उल्लिखित खोजें हैं, मुझे लगता है कि कुछ है, ओ (संख्याओं के बीच औसत अंतर)। औसत अंतर संख्या स्थान के आकार के साथ बढ़ता है, लेकिन संख्याओं की सूची की आवश्यक लंबाई के साथ घट जाती है।

तो रैखिक खोज की रणनीति बहुत खराब है, यदि संख्या स्थान बड़ा है (उदाहरण के लिए 4 बाइट इंट प्रकार के लिए, 0 से 2 ^ 32-1) और एन = 100। इस प्रदर्शन समस्या को हल करने के लिए, आप उपयुक्त कुंजी बनाने के लिए हैशटैब के समानांतर सेट रख सकते हैं, जहाँ संख्याएँ उच्च परिमाण (जैसे 1s, 10s, 100s, अधिकतम) पर गोल हैं। इस तरह आप आवश्यक खोजों को अधिक तेज़ी से करने के लिए गियर को ऊपर और नीचे कर सकते हैं। प्रदर्शन तब O (लॉग संख्या) हो जाता है, मुझे लगता है, जो निरंतर है, अर्थात O (1) भी।

इसे स्पष्ट करने के लिए, कल्पना करें कि आपके पास 197 नंबर है। आपने १० ’हैश टेबल पर hit 190’ मारा, यह निकटतम दस के लिए गोल है। कुछ भी? नहीं, तो आप 10 एस में नीचे जाते हैं जब तक आप कहते हैं कि 120। तब आप 1 एस हैशटेबल में 129 पर शुरू कर सकते हैं, फिर 128, 127 की कोशिश करें जब तक आप कुछ हिट न करें। अब आपने पाया है कि 197 नंबर डालने के लिए लिंक की गई सूची में। इसे डालते समय, आपको 1s हैशटेबल को 197 प्रविष्टि, 10 नंबर हैशटेबल के साथ 190 नंबर, 100 के साथ 100 नंबर, आदि के साथ अपडेट करना होगा। आपको कभी भी यहाँ करना होगा, संख्या सीमा के 10 गुना लॉग।

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

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

Comments

खोज को सम्मिलित फ़ंक्शन का हिस्सा होना चाहिए - वे स्वतंत्र कार्य नहीं हैं। चूँकि आपकी खोज O (n) है, आपका सम्मिलित कार्य भी O (n) है।

— कर्क ब्रॉडहार्ट

नहीं। मैंने जिस रणनीति का वर्णन किया है, उसका उपयोग करते हुए, संख्या स्थान को अधिक तेज़ी से पार करने के लिए अधिक हैशटेबल्स का उपयोग किया जाता है, यह ओ (1) है। कृपया मेरा जवाब फिर से पढ़ें।

— बेनेडिक्ट

@ निर्णय, आपका उत्तर काफी स्पष्ट रूप से कहता है कि चरण 4 और 7 में रैखिक खोजें हैं। रैखिक खोज O (1) नहीं हैं।

— पीटर टेलर

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

— बेनेडिक्ट

@ निर्णय आप सही हैं - खोज को छोड़कर, आपका उत्तर O (1) है। दुर्भाग्य से यह समाधान खोज के बिना काम नहीं करेगा।

— कर्क ब्रॉडहर्स्ट

Answer 9

क्या हम मान सकते हैं कि नंबर एक निश्चित डेटा प्रकार के हैं, जैसे कि इंटीजर? यदि ऐसा है, तो जोड़े गए प्रत्येक एकल संख्या का मिलान रखें। यह एक ओ (1) ऑपरेशन है।

1. किसी सरणी को उतने ही तत्वों के साथ घोषित करें जितनी संभव संख्याएँ हैं:
2. प्रत्येक संख्या को पढ़ें क्योंकि यह स्ट्रीम है।
3. टैली संख्या। इसे अनदेखा करें यदि यह संख्या पहले से 100 गुना अधिक हो गई है क्योंकि आपको इसकी आवश्यकता कभी नहीं होगी। यह ओवरफ्लो को कई बार अनंत काल तक रोकने से रोकता है।
4. चरण 2 से दोहराएँ।

VB.Net कोड:

Const Capacity As Integer = 100

Dim Tally(Integer.MaxValue) As Integer ' Assume all elements = 0
Do
    Value = ReadValue()
    If Tally(Value) < Capacity Then Tally(Value) += 1
Loop

जब आप सूची वापस करते हैं, तो आप जब तक चाहें ले सकते हैं। बस सूची के अंत से पुनरावृत्ति करें और दर्ज किए गए उच्चतम 100 मूल्यों की एक नई सूची बनाएं। यह एक ओ (एन) ऑपरेशन है, लेकिन यह बेमतलब है।

Dim List(Capacity) As Integer
Dim ListCount As Integer = 0
Dim Value As Integer = Tally.Length - 1
Dim ValueCount As Integer = 0
Do Until ListCount = List.Length OrElse Value < 0
    If Tally(Value) > ValueCount Then
        List(ListCount) = Value
        ValueCount += 1
        ListCount += 1
    Else
        Value -= 1
        ValueCount = 0
    End If
Loop
Return List

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

Answer 10

एक सौ नंबर आसानी से एक सरणी में संग्रहीत किए जाते हैं, आकार 100। किसी भी पेड़, सूची या सेट को ओवरकिल किया जाता है, जिसे हाथ में दिया जाता है।

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

चूंकि आप सूची को शुरुआत से क्रमबद्ध रखते हैं, इसलिए आपको किसी भी प्रकार के एल्गोरिथ्म को चलाने की आवश्यकता नहीं है। यह ओ (1) है।

Answer 11

आप एक बाइनरी मैक्स-हीप का उपयोग कर सकते हैं। आपको कम से कम नोड (जो अज्ञात / शून्य हो सकता है) के लिए एक पॉइंटर का ट्रैक रखना होगा।

आप पहले 100 नंबरों को ढेर में डालकर शुरू करते हैं। अधिकतम शीर्ष पर होगा। ऐसा होने के बाद, आप हमेशा 100 नंबर वहां रखेंगे।

फिर जब आपको एक नया नंबर मिलेगा:

if(minimumNode == null)
{
    minimumNode = findMinimumNode();
}
if(newNumber > minimumNode.Value)
{
    heap.Remove(minimumNode);
    minimumNode = null;
    heap.Insert(newNumber);
}

दुर्भाग्य findMinimumNodeसे ओ (एन) है, और आप उस लागत को एक बार डालने के लिए करते हैं (लेकिन डालने के दौरान नहीं :)। न्यूनतम नोड को निकालना और नए नोड को सम्मिलित करना, औसतन, ओ (1) है क्योंकि वे ढेर के नीचे की ओर जाएंगे।

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

बेशक, यदि एन निरंतर है, तो आपके पास हमेशा ओ (1) है। :)