कैसे तत्वों की अधिक से अधिक सेट खोजने के लिए

Question

मुझे एक एल्गोरिथम समस्या है।

$T$$n$$S$$T$$a\in S$$a\geqslant |S|$

उदाहरण के लिए:

1. यदि = [1, 3, 4, 1, 3, 6], तो [3, 3, 6] या [3, 4, 6] या [4, 3, 6] हो सकता है।$T$$S$
2. में = [7, 5, 1, 1, 7, 4], तो [7, 5, 7, 4]।$T$$S$

मैंने इस पुनरावर्ती कार्य की कोशिश की है।

function(T):
    if minimum(T) >= length(T): 
        return T
    else: 
        return function(T\minimum(T))

क्या कोई गैर-पुनरावर्ती एल्गोरिदम है। (मैंने अपने पुनरावर्ती एल्गोरिथ्म की जांच नहीं की, इसलिए इसमें कुछ दोष हो सकता है।)

Answer 1

क्रमबद्ध T. तब तत्वों को लें T[i] >= i+1।

उदाहरण के लिए sorted(T)=[6,4,3,3,1,1]। फिर, T[0] = 6 > 1, T[1] = 4 > 2, T[2] = 3 <= 3और अंत में, T[3] = 3 < 4तो हमारे पास है S = [T[0], T[1], T[2]]।

Comments

यह, निश्चित रूप से, अन्य समाधान याद करता है , लेकिन ऐसा प्रतीत होता है कि ओपी सभी समाधानों के बजाय किसी भी समाधान की तलाश कर रहा था । $\{6,3,3\}$

— रिक डेकर

इसे तत्वों की संख्या सही मिलती है। हम जानते हैं कि हमारे पास 3 तत्वों के साथ समाधान हैं, लेकिन 4 के साथ नहीं; इस मामले में हमारे पास 4 तत्व हैं, 3, इसलिए हम जानते हैं कि हम किसी भी 3 को समाधान के लिए चुन सकते हैं।

— gnasher729

मैं शुद्धता के तर्क की सराहना करता हूं।

— राफेल

मुझे लगता है कि आप शायद इसे O (n) समय में इंट्रोसेन्ट के एक संस्करण के साथ कर सकते हैं।

— user2357112

Answer 2

मूल रूप से मेरी टिप्पणी से: यह अकादमिक उत्पादकता मूल्यांकन में एक मात्रा सर्वव्यापी से संबंधित है, हिर्श इंडेक्स, जिसे इंडेक्स के$h$ रूप में जाना जाता है । संक्षेप में इसे परिभाषित किया गया है क्योंकि प्रकाशनों की संख्या एक है जिसमें उनमें से प्रत्येक में कम से कम h उद्धरण हैं (सबसे बड़ा ऐसा $h$$h$$h$ ) है।

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

आम तौर पर कार्यान्वित गणना बल्कि सीधी है और करोलिस जुडेलो के जवाब से सहमत है ।

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

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

-- just a utility function
merge :: [a] -> [a] -> [a]
merge [] ys = ys
merge (x:xs) ys = x : merge xs ys

-- the actual implementation
topImpl :: [Int] -> [Int] -> [Int]
topImpl [] granted = granted
topImpl (x:xs) granted
  | x == (1 + lGreater + lGranted) = x : merge greater granted
  | x > (1 + lGreater + lGranted) = topImpl smaller (x : merge greater granted)
  | otherwise = topImpl greater granted
  where smaller = [y | y <- xs, y < x]
        greater = [y | y <- xs, y >= x]
        lGreater = length greater
        lGranted = length granted

-- starting point is: top of whole array, granted is empty
top :: [Int] -> [Int]
top arr = topImpl arr []

विचार यह है grantedकि आप जो जानते हैं उसे परिणाम में इकट्ठा करेंगे, और आगे किसी भी तरह से नहीं छांटेंगे। यदि greaterएक साथ xफिट बैठता है, तो हम भाग्यशाली हैं, अन्यथा हमें एक छोटे उपसमूह के साथ प्रयास करने की आवश्यकता है। (धुरी xहै कि सबसे बड़ा तत्व एक विकेट एक के बाद के खिलाफ महत्वपूर्ण लाभ हम के औसत आकार के ब्लॉक पर ऐसा कर वह यह है कि बस जो कुछ भी sublist है कि वर्तमान में माना जाता है के पहले आइटम हुआ है।) नोट $remaining/2$ और उन्हें आगे क्रमबद्ध करने की आवश्यकता नहीं है।

उदाहरण:

चलो अपना सेट ले लो [1,3,4,1,3,6]।

1. x = 1, granted = [], greater = [3,4,1,3,6]। आउच, हमने एक पैथोलॉजिकल मामले को हिट किया जब पिवट बहुत छोटा है (वास्तव में इतना छोटा है कि smallerखाली है) पहले चरण में सही है। सौभाग्य से हमारा अहंकार इसके लिए तैयार है। यह अकेले के xसाथ फिर से प्रयास करता है greater।

2. x = 3, granted = [], greater = [4,3,6]। साथ में, वे लंबाई 4 की एक सरणी बनाते हैं, लेकिन हमारे पास केवल 3 से नीचे तक सीमित है इसलिए यह बहुत अधिक है। greaterअकेले पर दोहराएं ।

3. x = 4, granted = [], greater = [6]। यह प्रत्येक को 2 तत्वों ≥ 4 की एक सरणी देता है, लगता है कि हम उनमें से कुछ के लिए उपयोग कर सकते हैं। इसे रखें और दोहराएं smaller = [3]।

4. x = 3, granted = [4,6], greater = []। यह एक साथ 3 तत्वों each 3 प्रत्येक की एक सरणी देता है, इसलिए हमारे पास हमारा समाधान है [3,4,6]और हम वापस लौट सकते हैं। (ध्यान दें कि क्रमांकन इनपुट के आदेश के आधार पर भिन्न हो सकता है, लेकिन इसमें हमेशा उच्चतम संभव शब्द होंगे, कभी भी [3,3,6]या [3,3,4]उदाहरण के लिए नहीं।)

(Btw। ध्यान दें कि पुनरावृत्ति वास्तव में सिर्फ एक चक्र तक ढह गई थी।) कई बचाया तुलनाओं की वजह से जटिलता क्विकसॉर्ट से कुछ बेहतर है:

$n-1$ तुलना

$O(\log n)$$O(n)$ कुल तुलना

$n$$O(n^2)$ तुलना कुल

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

Answer 3

आपके एल्गोरिथ्म में कुछ भी गलत नहीं है, और निश्चित रूप से अधिकांश पुनरावर्ती एल्गोरिदम को लूप में परिवर्तित किया जा सकता है, यहां आपके पुनरावर्ती कोड का एक लूप संस्करण है:

function(T):
    while minimum(T) <= lenght(T):
         remove minimum(T) from T
    loop

Comments

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

— डेविड रिचरबी

Answer 4

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

Answer 5

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

जब तक आप दिए गए सीमा से अधिक नहीं हो जाते, तब तक तत्वों को लालच में रखें।

Comments

यहाँ भी, मैं शुद्धता के विचार की सराहना करता हूँ।

— राफेल