दिलचस्प पोस्ट
कैसे माँगोडब में स्ट्रिंग को संख्यात्मक मानों में कनवर्ट करना MVC मॉडल से एक बाइट सरणी छवि प्रदर्शित करने के लिए कैसे क्या PHP पीडीओ वक्तव्य पैरामीटर के रूप में तालिका या स्तंभ नाम स्वीकार कर सकता है? बाल तत्व पर मार्जिन मूल तत्व को स्थानांतरित करता है कार्यवाही के नीचे छाया निकालें सरणी सूची से सरणी का पेड़ बनाएं MySQL में बाइनरी डेटा कैसे int को कन्वर्ट करने के लिए? पाठ-ओवरफ्लो: फ़ायरफ़ॉक्स 4 में एलीप्सिस? (और एफएफ 5) पायथन में फ़ंक्शन से मैं दो मान कैसे वापस कर सकता हूँ? मैं स्ट्रिंग कैसे कर सकता हूँ। .NET में एक कस्टम प्रारूप के साथ एक टाइमस्पैन ऑब्जेक्ट फॉर्मेट करें? जावा में "अपरिवर्तनीय बयान" कंपाइलर त्रुटि क्यों है? PHP: मैं फ़ाइल बनाने की तारीख कैसे प्राप्त करूं? सत्र Nodes.js के साथ Express.js में कैसे काम करते हैं? दृश्य नियंत्रकों के बीच संवाद करने का सबसे अच्छा तरीका क्या है?

संभावित साक्षात्कार प्रश्न: सभी अतिव्यापी अंतराल कैसे खोजें

यह एक साक्षात्कार का प्रश्न नहीं है , जैसा कि मैंने इस पर मेरे प्रोजेक्ट में आया था, लेकिन मुझे लगा कि यह एक सभ्य हस्तक्षेप प्रश्न हो सकता है।

आपके पास अंतराल के एन जोड़े हैं, पूर्णांक कहते हैं। आपको उन अंतरालों को इन्डेन्ट करने की आवश्यकता है जो ओ (एन) समय में एक-दूसरे के साथ ओवरलैप करते हैं। उदाहरण के लिए, यदि आपके पास है

{1, 3} {12, 14} {2, 4} {13, 15} {5, 10}

उत्तर {1, 3}, {12, 14}, {2, 4}, {13, 15} है। ध्यान दें कि आपको उन्हें समूह की आवश्यकता नहीं है, इसलिए परिणाम किसी भी क्रम में हो सकता है जैसे कि उदाहरण में।

मैंने ओ (एन) के समय में फेंक दिया क्योंकि KMP एल्गोरिथम स्ट्रिंग खोज के लिए हे (एन) लेता है। : डी

सबसे अच्छा मैं के साथ आया था और मैं इस परियोजना में अभी क्या उपयोग कर रहा हूँ ओ (एन ^ 2) है हाँ, क्रूर बल बहुत उदास है, लेकिन कोई भी शिकायत नहीं करता है इसलिए मैं इसे पुनर्संसर नहीं करेगा। : पी फिर भी, मैं उत्सुक था अगर एक बड़ा दिमाग एक अधिक सुरुचिपूर्ण समाधान है

वेब के समाधान से एकत्रित समाधान "संभावित साक्षात्कार प्रश्न: सभी अतिव्यापी अंतराल कैसे खोजें"

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

1S, 2S, 3E, 4E, 5S, 10E, 12S, 13S, 14E, 15E 

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

 1S, 2S, 3E, 4E, 5S, 10E, 12S, 13S, 14E, 15E ^ ^ overlap overlap 

हमें पता चलता है कि कौन सा अंतराल ओवरलैप हो सकता है, जिसके साथ अंत-अंक के साथ डेटा संग्रहीत करके और हम किस अंतराल में हैं।

यह मुख्य कारक के रूप में सॉर्टिंग के साथ एक हे (एन लॉगएन) समाधान है

प्रारंभ बिंदु से अंतराल सॉर्ट करें। फिर इस सूची में गुना, अपने पड़ोसी (यानी (1,4), (2,6) -> (1,6)) के साथ प्रत्येक अंतराल को मिलाकर अगर वे ओवरलैप करते हैं। परिणामस्वरूप सूची में कोई अंतराल नहीं है जिसमें अतिव्यापी भागीदार नहीं है। इन मूल सूची से फ़िल्टर करें

यह प्रारंभिक प्रकार की कार्रवाई के बाद समय में रैखिक है जो किसी भी (एन लॉग एन) एल्गोरिथम के साथ किया जा सकता है। सुनिश्चित नहीं है कि आप उस स्थान पर कैसे पहुंचेंगे यहां तक ​​कि अंत में 'फ़िल्टर आउट डुप्लिकेट' ऑपरेशन रैखिक है अगर आप पहले ऑपरेशन के इनपुट और आउटपुट के पहले से सॉर्ट किए गए ऑर्डर का लाभ उठाते हैं।

यहां हास्केल में एक कार्यान्वयन है:

 -- Given a list of intervals, select those which overlap with at least one other inteval in the set. import Data.List type Interval = (Integer, Integer) overlap (a1,b1)(a2,b2) | b1 < a2 = False | b2 < a1 = False | otherwise = True mergeIntervals (a1,b1)(a2,b2) = (min a1 a2, max b1 b2) sortIntervals::[Interval]->[Interval] sortIntervals = sortBy (\(a1,b1)(a2,b2)->(compare a1 a2)) sortedDifference::[Interval]->[Interval]->[Interval] sortedDifference [] _ = [] sortedDifference x [] = x sortedDifference (x:xs)(y:ys) | x == y = sortedDifference xs ys | x < y = x:(sortedDifference xs (y:ys)) | y < x = sortedDifference (x:xs) ys groupIntervals::[Interval]->[Interval] groupIntervals = foldr couldCombine [] where couldCombine next [] = [next] couldCombine next (x:xs) | overlap next x = (mergeIntervals x next):xs | otherwise = next:x:xs findOverlapped::[Interval]->[Interval] findOverlapped intervals = sortedDifference sorted (groupIntervals sorted) where sorted = sortIntervals intervals sample = [(1,3),(12,14),(2,4),(13,15),(5,10)] 

अंतराल-ऑन-द-लाइन समस्याओं के लिए मानक दृष्टिकोण उन्हें शुरुआती बिंदु के अनुसार क्रमबद्ध करना है और फिर पहले से अंतिम तक चलना है। O(n*logn) ( O(n) यदि पहले से ही सॉर्ट किया गया है)

 end = 0; for (current in intervals) { if current.start < end { // there's an intersection! // 'current' intersects with some interval before it ... } end = max(end, current.end) } 

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

तो आपको पहले मिलेगा:

{1, 3}, {2,4}, {5, 10}, {12, 14}, {13, 15}

4 (सबसे बड़े) <5 और 10 <12, {5, 10} पृथक होने के बाद से अलग है।

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

यह सॉर्टिंग एल्गोरिथम की दक्षता पर निर्भर करता है, क्योंकि बाद की प्रक्रिया ओ (एन) होगी,

मान लीजिए कि प्रारंभ और समापन बिंदुओं के बीच का अंतर छोटा है, कहें <32. उदाहरण के लिए 1..32। फिर प्रत्येक अंतराल को 32 बिट शब्द में एक बिट पैटर्न के रूप में लिखा जा सकता है। जैसे [1, 2] -> 001; [2, 3]-> 010; [1, 3] -> 011; [2, 3, 4] -> 110 [1, 2] -> 001; [2, 3]-> 010; [1, 3] -> 011; [2, 3, 4] -> 110 [1, 2] -> 001; [2, 3]-> 010; [1, 3] -> 011; [2, 3, 4] -> 110 दो अंतराल, या अंतराल के संयोजन, यदि उनकी बिटवर्ड AND गैर-शून्य है तो ओवरलैप करें। जैसे। [1,2] ओवरलैप [1,3] क्योंकि 001&011 == 001 , गैर-शून्य। ओ (एन) एल्ग एक चल बिटिंग या अंतराल बनाए रखने के लिए है ताकि अब तक और प्रत्येक नए एक:

 bitsSoFar = 0 for (n=0; n < bitPatterns.length; n++) if (bitPatterns[n] & bitsSoFar != 0) // overlap of bitPatterns[n] with an earlier pattern bitsSoFar |= bitPatterns[n] 

एक व्यायाम के रूप में वाम:

  • एल्गोरिथ्म को संशोधित करने के लिए बाद में एक के साथ थोड़ी पैटर्न के ओवरलैप की पहचान करें

  • ओ में एक अंतराल के लिए बिट पैटर्न का काम करना (1)

अगर अंतराल के एन जोड़े पूर्णांक हैं, तो हम इसे ओ (एन) में प्राप्त कर सकते हैं।

इसे क्रम में पहली संख्या से क्रमबद्ध करें, फिर दूसरी संख्या। यदि सभी पूर्णांक हैं, तो हम ओ (एन) द्वारा इसे प्राप्त करने के लिए बाल्टी सॉर्ट या रेडिक्स सॉर्ट का उपयोग कर सकते हैं।

{1, 3}, {2,4}, {5, 10}, {12, 14}, {13, 15}

फिर एक-एक करके,

{1,3}

ओवरलैप {1,3} और {2,4} के साथ {1,4}

{1,4}, {5,10}

{1,4}, {5,10}, {12,14}

{1,4}, {5,10}, {12,15} ओवरलैप {12,14} और {13,15} के साथ

संयोजन ओ (एन) समय ले जाएगा

इस समस्या को तत्व विशिष्टता समस्या में कम किया जा सकता है

तत्व विशिष्टता ओमेगा (एन लॉग एन) निचला बाध्य है (तुलना की संख्या की गणना), ताकि आप उस से बेहतर नहीं कर सकते

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

मैं खोजता हूं कि यह कार्यान्वयन

ब्रेट

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

 int find_no_overlapping_intervals(const vector< pair<int, int>& a) { // a[i].first -> X ,a[i].second->Y // sort by start time sort.begin(a.begin(), a.end()); // maintain <end-time, its frequency> in m map<int, int> m; // i // for each point, we know its a[i].X >= a[0].X. ....a[i-1].X // there will be overlap, if for some j < i, a[j].Y >= a[i].X // lower_bound to find this.. it can be found in O(log(n)) as we use std::map for maintaining y int ans = 0; for (int i=0; i < a.begin(); i++) { auto sit = m.lower_bound(m.begin(), m.end(), a[i].first); auto eit = m.upper_bound(m.begin(), m.end(), a[i].first); for (auto it = sit; it != eit; it++) ans += it->second; m[a[i].second]++; } return ans; } 
 public ArrayList<Interval> merge(ArrayList<Interval> intervals) { ArrayList<Interval> res = new ArrayList<Interval>(); if (intervals == null || intervals.isEmpty()) return res; Comparator<Interval> comparator = new Comparator<Interval>() { @Override public int compare(Interval i1, Interval i2) { if (i1.start < i2.start) return -1; else if (i1.start > i2.start) return 1; else { if (i1.end < i2.end) return -1; else if (i1.end > i2.end) return 1; else return 0; } } }; Collections.sort(intervals, comparator); for (int i = 0; i < intervals.size(); i++) { Interval cur = intervals.get(i); if (res.isEmpty()) { res.add(cur); } else { Interval last = res.get(res.size() - 1); if (last.end >= cur.start) { last.end = Math.max(last.end, cur.end); } else { res.add(cur); } } } return res; } 

यह एक सरल O(N*log(N)) पायथन में कार्यान्वयन है:

 def overlapping(intervals): last = (-1, -1) overlapping = set() for curr in sorted(intervals, key=lambda p: p[0]): if curr[0] < last[1]: overlapping.add(curr) overlapping.add(last) last = max(curr, last, key=lambda p: p[1]) return list(overlapping - set((-1, -1))) print overlapping([(1, 3), (12, 14), (2, 4), (13, 15), (5, 10)]) #=> [(1, 3), (13, 15), (2, 4), (12, 14)] 

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

छँटाई का हिस्सा वह है जो सबसे अधिक समय की आवश्यकता है, इसलिए अंतिम जटिलता N*log(N)

एक स्वीप लाइन एल्गोरिदम ( O(N log N) का उपयोग करके सी ++ में कार्यान्वयन:

 #include <algorithm> #include <iostream> #include <set> #include <tuple> #include <vector> struct Interval { double start; double end; }; //----------------------------------------------------------------------------- // Enum to qualify event: Start/End of "segment-line" enum class EIntervalState { Start, End }; //----------------------------------------------------------------------------- // Events used for collision detection struct Event { double pos; EIntervalState state; std::size_t id; }; //----------------------------------------------------------------------------- // Comparator to use if {1, 2} and {2, 3} should overlap class LessIncludeLimit { public: bool operator()(const Event& lhs, const Event& rhs) const { return std::tie(lhs.pos, lhs.state) < std::tie(rhs.pos, rhs.state); } }; //----------------------------------------------------------------------------- // Comparator to use if {1, 2} and {2, 3} should not overlap class LessExcludeLimit { public: bool operator()(const Event& lhs, const Event& rhs) const { return std::tie(lhs.pos, rhs.state) < std::tie(rhs.pos, lhs.state); } }; //----------------------------------------------------------------------------- std::vector<Event> MakeEvents(const std::vector<Interval>& intervals) { std::vector<Event> res; std::size_t id = 0; for (const auto& interval : intervals) { res.push_back({interval.start, EIntervalState::Start, id}); res.push_back({interval.end, EIntervalState::End, id}); ++id; } return res; } //----------------------------------------------------------------------------- template <typename Less> std::vector<std::pair<std::size_t, std::size_t>> ComputeOverlappingIntervals(std::vector<Event>&& events, Less less) { std::sort(events.begin(), events.end(), less); std::set<std::size_t> activeIds; std::vector<std::pair<std::size_t, std::size_t>> res; for (const auto& event : events) { switch (event.state) { case EIntervalState::Start: { for (const auto& id : activeIds) { res.emplace_back(std::minmax(event.id, id)); } activeIds.emplace(event.id); break; } case EIntervalState::End: { activeIds.erase(event.id); break; } } } return res; } 

और इसका प्रयोग करें:

 int main() { const std::vector<Interval> intervals = { {1, 3}, {12, 14}, {2, 4}, {13, 15}, {5, 10} }; for (const auto& p : ComputeOverlappingIntervals(MakeEvents(intervals), LessExcludeLimit{})) { std::cout << "intervals " << p.first << " and " << p.second << " overlap\n"; } } 

डेमो

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

फिर आप दूसरी बार सूची पर जा सकते हैं, और हर अंतराल के लिए हैश तालिका में जांच करें कि यह मर्ज किए गए अंतराल में है या नहीं।

मुझे नहीं पता कि यह ओ (एन) है, लेकिन यह ओ (एन ^ 2) से काफी बेहतर है।