कोडिंग इंटरव्यू: ओवरलैपिंग इंटरवल्स (Intervals) को कैसे मर्ज करें?

प्रॉम्प्ट और दायरा

क्लोज्ड इंटरवल्स की एक अनसॉर्टेड लिस्ट intervals दिए जाने पर, जहाँ प्रत्येक आइटम [start, end] और start <= end है, सभी ओवरलैप्स को मर्ज करें। एक नई लिस्ट लौटाएं जो start द्वारा सॉर्ट की गई हो, pairwise disjoint हो, और बिल्कुल समान पॉइंट्स को कवर करती हो। यह समस्या क्लोज्ड इंटरवल्स का उपयोग करती है, इसलिए [1, 4] और [4, 5] पॉइंट 4 साझा करते हैं और उन्हें [1, 5] बनना चाहिए। फ़ंक्शन को अपने इनपुट को म्यूटेट (बदलना) नहीं चाहिए।

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

Input:  [[8, 10], [1, 3], [2, 6], [15, 18]]
Output: [[1, 6], [8, 10], [15, 18]]

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

इंटरव्यूअर क्या मूल्यांकन करता है

पहला संकेत यह है कि क्या उम्मीदवार इंटरवल सेमेंटिक्स को परिभाषित करता है। क्लोज्ड इंटरवल्स, हाफ-ओपन इंटरवल्स, और केवल आसन्न (adjacent) रेंजों को मर्ज करने वाला नियम अलग-अलग स्थितियां उत्पन्न कर सकते हैं। अनुबंध बताए बिना start < current_end लिखने से साझा-एंडपॉइंट वाला केस विफल हो सकता है।

दूसरा संकेत यह है कि क्या उम्मीदवार समझा सकता है कि सॉर्टिंग कैसे मदद करती है। सॉर्टिंग के बाद, अगला start वर्तमान start से छोटा नहीं हो सकता। यदि यह वर्तमान मर्ज किए गए इंटरवल के end से पहले से ही बड़ा है, तो बाद का प्रत्येक start भी बड़ा होगा, इसलिए वर्तमान इंटरवल को सुरक्षित रूप से आउटपुट (emit) किया जा सकता है। एक मजबूत उत्तर केवल "सॉर्ट और स्कैन" कहने के बजाय यह अंतिम रूप देने वाला तर्क (finalization argument) देता है।

तीसरा संकेत कंटेनमेंट (एक-दूसरे में समाहित होना) को संभालना है। जब [1, 10] का सामना [2, 3] से होता है, तो मर्ज किया गया end max(10, 3) होना चाहिए। इसे 3 से ओवरराइट करने पर कवर किए गए पॉइंट्स खो जाते हैं। चेन्ड ओवरलैप्स की तुलना भी केवल पिछले रॉ इनपुट इंटरवल से नहीं, बल्कि विस्तारित हो रहे मर्ज किए गए इंटरवल से की जानी चाहिए।

इंटरव्यूअर म्यूटेशन अनुबंध, जटिलता और वैलिडेशन रणनीति की भी जांच करेगा। सॉर्टिंग आमतौर पर O(n log n) रनिंग टाइम तय करती है। यह कार्यान्वयन इनपुट को अपरिवर्तित रखने के लिए सॉर्ट की गई कॉपी और परिणाम पर O(n) स्पेस खर्च करता है। परीक्षणों को मानक उदाहरण से आगे जाना चाहिए: यह सत्यापित करें कि इनपुट अपरिवर्तित है, आउटपुट क्रमित और डिसजॉइंट है, और रैंडमाइज़्ड परिणाम धीमे संदर्भ कार्यान्वयन (reference implementation) से मेल खाते हैं।

उत्तर देने से पहले स्पष्टीकरण हेतु प्रश्न

• क्या ये क्लोज्ड इंटरवल्स हैं या हाफ-ओपन, और क्या साझा एंडपॉइंट्स मर्ज होते हैं? ये यहाँ क्लोज्ड हैं, इसलिए शर्त next_start <= current_end है। यदि प्रोडक्ट निकटता को अलग मानता है, तो सख्त तुलना (strict comparison) का उपयोग करें। [a, b) के लिए, क्या सन्निहित (contiguous) लेकिन गैर-ओवरलैपिंग रेंज मर्ज होते हैं, यह एक अलग विकल्प है।
• क्या इनपुट पहले से ही start के अनुसार सॉर्टेड है? सॉर्ट किए गए इनपुट के लिए केवल एक लीनियर स्कैन की आवश्यकता होती है, जिससे समय घटकर O(n) हो जाता है। अनसॉर्टेड इनपुट के लिए सॉर्टिंग या सीमित एंडपॉइंट डोमेन से जुड़ी एक विशेष विधि की आवश्यकता होती है।
• क्या मैं इनपुट को म्यूटेट कर सकता हूँ? यदि हाँ, तो इन-प्लेस सॉर्ट करें और राइट पॉइंटर (write pointer) के साथ कॉम्पैक्ट करें। यदि नहीं, तो डेटा को कॉपी करें या एक ऐसे सॉर्टिंग ऑपरेशन का उपयोग करें जो एक नई लिस्ट लौटाता है।
• क्या एंडपॉइंट्स एक छोटी सीमित सीमा के पूर्णांक हैं? मनमाने तुलनीय मानों के लिए तुलना सॉर्टिंग (comparison sorting) सीधा विकल्प है। एक छोटा पूर्णांक यूनिवर्स बकेट्स या डिफरेंस ऐरे की अनुमति दे सकता है, लेकिन इसकी लागत केवल n के बजाय कोऑर्डिनेट रेंज पर निर्भर करती है।
• क्या यह एकमुश्त ऑफ़लाइन मर्ज है या एक निरंतर स्ट्रीम? start के अनुसार क्रमित स्ट्रीम को ऑनलाइन मर्ज और एमिट किया जा सकता है। एक मनमाने क्रम वाली स्ट्रीम को सुरक्षित रूप से जल्दी अंतिम रूप नहीं दिया जा सकता क्योंकि भविष्य का इंटरवल पहले शुरू हो सकता है और मौजूदा घटकों को जोड़ सकता है।
• क्या आउटपुट को केवल सीमाओं की आवश्यकता है, या इसे इंटरवल मेटाडेटा को संरक्षित करना चाहिए? सीमाओं को मर्ज करने से यह परिभाषित नहीं होता कि लेबल, अनुमतियाँ या कीमतें कैसे संयोजित होती हैं। मेटाडेटा के लिए एक स्पष्ट एकत्रीकरण (aggregation) नियम की आवश्यकता होती है।

30-सेकंड उत्तर रूपरेखा

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

चरण-दर-चरण गहन विश्लेषण

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

सॉर्टिंग वैश्विक समस्या को बाएं-से-दाएं स्कैन में बदल देती है। (start, end) आरोही क्रम में सॉर्ट करें। current = [current_start, current_end] को बनाए रखें, जो संसाधित इंटरवल्स के बीच अंतिम मर्ज किया गया कंपोनेंट है जिसे अभी तक एमिट नहीं किया गया है। प्रत्येक अगले [start, end] के लिए:

1. यदि start <= current_end है, तो दोनों क्लोज्ड इंटरवल्स ओवरलैप करते हैं, इसलिए current_end को max(current_end, end) पर सेट करें।
2. यदि start > current_end है, तो एक गैप (अंतर) है। प्रत्येक बाद का start कम से कम start है, इसलिए कोई भी भविष्य का इंटरवल current तक नहीं पहुँच सकता। इसे एमिट करें और एक नया वर्तमान इंटरवल शुरू करें।

स्कैन तीन इनवेरिएंट्स (अपरिवर्तनीय नियमों) को बनाए रखता है:

1. एमिट किए गए इंटरवल्स सॉर्टेड, pairwise disjoint हैं, और कभी नहीं बदलेंगे।
2. एमिट किए गए इंटरवल्स और current का यूनियन सभी संसाधित इनपुट इंटरवल्स के यूनियन के बराबर है।
3. current संसाधित इंटरवल्स के बीच अंतिम अधिकतम (maximal) मर्ज किया गया कंपोनेंट है और एकमात्र कंपोनेंट है जो अगले इंटरवल के साथ ओवरलैप कर सकता है।

तीनों पहले सॉर्ट किए गए इंटरवल से इनिशियलाइज़ करने के बाद लागू होते हैं। एक ओवरलैप केवल अंतिम कंपोनेंट के दाएँ एंडपॉइंट का विस्तार करता है और इसके यूनियन को बनाए रखता है। गैप पर, सॉर्टिंग यह गारंटी देती है कि प्रत्येक भविष्य का start current_end से परे है, इसलिए एमिशन सुरक्षित है। आगमन विधि (induction) द्वारा, इनवेरिएंट्स पूरे स्कैन के दौरान बने रहते हैं। अंत में एक बार फिर current को एमिट करने से एक समतुल्य यूनियन प्राप्त होता है जिसमें कोई भी युग्म आगे मर्ज नहीं हो सकता।

def merge_intervals(intervals: list[list[int]]) -> list[list[int]]:
    if not intervals:
        return []

    ordered = sorted((start, end) for start, end in intervals)
    merged: list[list[int]] = []
    current_start, current_end = ordered[0]

    for start, end in ordered[1:]:
        if start <= current_end:
            current_end = max(current_end, end)
        else:
            merged.append([current_start, current_end])
            current_start, current_end = start, end

    merged.append([current_start, current_end])
    return merged

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

वैलिडेशन में खाली इनपुट, एक इंटरवल, सभी-डिसजॉइंट इंटरवल्स, साझा एंडपॉइंट्स, पूर्ण समावेशन (full containment), डुप्लिकेट्स, नकारात्मक एंडपॉइंट्स और चेन्ड ओवरलैप्स शामिल होने चाहिए। उदाहरण के लिए, [[1, 2], [2, 3], [3, 4]] को [[1, 4]] बनना चाहिए; यह उस कोड को पकड़ता है जो केवल आसन्न रॉ इंटरवल्स की तुलना करता है। एक डीप कॉपी रखें और दावा (assert) करें कि कॉल इसे नहीं बदलता है। फिर छोटे यादृच्छिक इनपुट उत्पन्न करें और एक धीमे ऑरेकल के विरुद्ध तुलना करें जो किसी भी ओवरलैपिंग जोड़ी को बार-बार मर्ज करता है। उपरोक्त कार्यान्वयन का 10,000 फिक्स्ड-सीड यादृच्छिक मामलों पर डिफरेंशियल-टेस्ट किया गया था।

एक तुलना मॉडल में मनमाने मानों के लिए, सॉर्ट और स्कैन स्पष्ट सामान्य उत्तर है। जब n बहुत छोटा हो, तो दोहराया गया युग्म विलय छोटा हो सकता है और इसकी धीमी सीमा कोई मायने नहीं रख सकती है। पहले से सॉर्ट किए गए इनपुट के लिए केवल स्कैन की आवश्यकता होती है। एक छोटा सीमित पूर्णांक डोमेन बकेट्स या डिफरेंस-ऐरे तकनीक को सही ठहरा सकता है जिसकी लागत कोऑर्डिनेट यूनिवर्स पर निर्भर करती है। एक इंटरव्यू में, ऐसे विशेष मामलों को केवल तभी प्रस्तुत करें जब सीमाएं उन्हें उचित ठहराती हों।

उच्च-गुणवत्ता वाला नमूना उत्तर

"मैं पहले सीमा को स्पष्ट करूँगा: इनपुट में अनसॉर्टेड क्लोज्ड इंटरवल्स हैं, एंडपॉइंट साझा करना ओवरलैप माना जाता है, और मुझे नया डेटा लौटाना होगा। इसका मतलब है कि [1, 4] और [4, 5] एक लेस-दैन-ऑर-इक्वल (<=) परीक्षण का उपयोग करते हैं।

एक ब्रूट-फ़ोर्स संस्करण जोड़े ढूंढना और पुनः आरंभ करना जारी रख सकता है, लेकिन नया मर्ज किया गया इंटरवल पहले देखी गई किसी चीज़ के साथ ओवरलैप हो सकता है, इसलिए इसे कई पास की आवश्यकता हो सकती है। मैं start के अनुसार सॉर्ट करूँगा और केवल एक इंटरवल रखूँगा जो अभी तक अंतिम नहीं है। जब अगला start इसके end के अंदर होता है, तो मैं इसे बड़े end के साथ विस्तारित करता हूँ। अन्यथा मैं इसे परिणाम में लिखता हूँ और एक नया घटक शुरू करता हूँ।

महत्वपूर्ण तुलना संचित (accumulated) घटक के साथ है, न कि केवल पिछले रॉ इंटरवल के साथ। सॉर्टिंग गारंटी देती है कि एक बार जब अगला start वर्तमान end से अधिक हो जाता है, तो हर बाद का start भी बढ़ जाता है, इसलिए वर्तमान परिणाम स्थायी रूप से अंतिम होता है। इसलिए एमिट किया गया प्रीफ़िक्स क्रमित और डिसजॉइंट रहता है, जबकि वर्तमान इंटरवल संसाधित इनपुट के अंतिम मर्ज किए गए घटक को ठीक से कवर करता है।

मैं कॉलर की लिस्ट को बदलने से बचने के लिए sorted() का उपयोग करूँगा और खाली इनपुट के लिए जल्दी वापस आ जाऊँगा। समय सॉर्टिंग और एक लीनियर स्कैन के लिए O(n log n) है, और सॉर्ट की गई कॉपी और आउटपुट O(n) स्पेस का उपयोग करते हैं। मैं टचिंग, नेस्टेड, डुप्लिकेट, नेगेटिव और चेन्ड इंटरवल्स का परीक्षण करूँगा, फिर धीमे पेयरवाइज मर्जिंग के खिलाफ डिफरेंशियल-टेस्ट करूँगा और यह भी दावा करूँगा कि इनपुट नहीं बदला।"

सामान्य गलतियाँ

• एंडपॉइंट सेमेंटिक्स को परिभाषित किए बिना < या <= चुनना → साझा-एंडपॉइंट परिणाम अनुबंध पर निर्भर करता है → शर्त चुनने से पहले क्लोज्ड बनाम हाफ-ओपन सेमेंटिक्स बताएं और बताएं कि क्या सन्निहित रेंज मर्ज होते हैं।
• मूल क्रम में स्कैन करना → ओवरलैपिंग इंटरवल्स बहुत दूर हो सकते हैं और भविष्य का इंटरवल उत्सर्जित आउटपुट को फिर से जोड़ सकता है → start के अनुसार सॉर्ट करें, जब तक कि सॉर्ट किया गया इनपुट गारंटीकृत न हो।
• केवल आसन्न रॉ इंटरवल्स की तुलना करना → [1, 10], [2, 3], [9, 12] में तीसरा आइटम विस्तारित [1, 10] से मिलना चाहिए → हमेशा अंतिम मर्ज किए गए परिणाम के साथ तुलना करें।
• ओवरलैप पर current_end = end असाइन करना → एक समाहित इंटरवल कवर की गई सीमा को सिकोड़ देता है → max(current_end, end) का उपयोग करें।
• अंतिम अपेंड भूल जाना → केवल अंतराल पर उत्सर्जित करने वाला लूप अंतिम घटक को खो देता है → लूप के बाद एक बार current जोड़ें।
• खाली इनपुट के लिए पहले आइटम को पढ़ना → इनिशियलाइज़ेशन से इंडेक्स एरर उत्पन्न होता है → सॉर्टिंग और इनिशियलाइज़ेशन से पहले एक खाली लिस्ट लौटाएं।
• म्यूटेशन न करने का वादा करना लेकिन इन-प्लेस सॉर्ट करना → कॉलर पुन: व्यवस्थित इनपुट देखता है, और पुन: उपयोग की गई आंतरिक सूचियाँ बदलती रह सकती हैं → sorted() और नए परिणाम ऑब्जेक्ट का उपयोग करें, या म्यूटेशन को अनुबंध का हिस्सा बनाएं।
• केवल अपेक्षित ऐरे का परीक्षण करना → चेन्ड ओवरलैप्स, म्यूटेशन और सीमा त्रुटियां छिपी रह सकती हैं → प्रॉपर्टी चेक और एक रैंडमाइज़्ड डिफरेंशियल ऑरेकल जोड़ें।
• दावा करना कि O(n log n) हमेशा अपरिहार्य है → सॉर्ट किया गया इनपुट और छोटे सीमित पूर्णांक डोमेन तुलना सॉर्टिंग से बच सकते हैं → निचली-सीमा के दावे को अनसॉर्टेड मनमाने तुलनीय एंडपॉइंट्स तक सीमित करें।

फॉलो-अप्स और उन्हें कैसे संभालें

फॉलो-अप 1: यदि साझा एंडपॉइंट्स को ओवरलैप नहीं माना जाता है तो क्या बदलता है?

शर्त को start <= current_end से start < current_end में बदलें। पहले डोमेन की भाषा की पुष्टि करें: क्लोज्ड इंटरवल्स जो एक एंडपॉइंट साझा करते हैं वे गणितीय रूप से प्रतिच्छेद करते हैं, इसलिए एक प्रोडक्ट जो उन्हें अलग रखता है वह वास्तव में केवल सकारात्मक-लंबाई वाले ओवरलैप को मर्ज करने के लिए कह रहा है। हाफ-ओपन [a, b) के लिए, [1, 4) और [4, 5) ओवरलैप नहीं करते हैं; सन्निहित रेंजों को मिलाना तब एक अन्य स्वतंत्र नियम है।

फॉलो-अप 2: इनपुट सॉर्टेड है और म्यूटेशन की अनुमति है। आप अतिरिक्त स्पेस कैसे कम कर सकते हैं?

सॉर्टिंग छोड़ें और राइट पॉइंटर के साथ इनपुट प्रीफ़िक्स में कॉम्पैक्ट करें। एक रीड पॉइंटर नए इंटरवल्स का दौरा करता है। ओवरलैप पर, राइट पोज़ीशन पर end को अपडेट करें; गैप पर, राइट पॉइंटर को आगे बढ़ाएं और नए इंटरवल को कॉपी करें। प्रीफ़िक्स की लंबाई या उस प्रीफ़िक्स का एक दृश्य (view) लौटाएं। मूल इनपुट को नष्ट करने की कीमत पर, स्कैन में O(n) समय और लौटाए गए प्रतिनिधित्व को छोड़कर O(1) सहायक स्थान लगता है।

फॉलो-अप 3: इंटरवल्स लगातार start क्रम में आते हैं। क्या आप एक स्ट्रीम एमिट कर सकते हैं?

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

फॉलो-अप 4: क्या होगा यदि दस करोड़ इंटरवल्स मेमोरी में फिट नहीं होते हैं?

start के अनुसार एक एक्सटर्नल सॉर्ट का उपयोग करें: मेमोरी-आकार के बैचों को क्रमित रन (ordered runs) में सॉर्ट करें, फिर एक k-way मर्ज करें। मर्ज स्ट्रीम पहले से ही start-क्रमित है, इसलिए पहले एक पूर्ण विश्व स्तर पर सॉर्ट की गई फ़ाइल को साकार करने के बजाय मर्ज करते समय समान एक-इंटरवल स्टेट मशीन चलाएं। तुलना का कार्य O(n log n) के क्रम में रहता है; डिस्क I/O और अस्थायी स्टोरेज महत्वपूर्ण अतिरिक्त लागत बन जाते हैं।

फॉलो-अप 5: क्या कीमतों या अनुमति लेबल वाले इंटरवल्स को सीधे मर्ज किया जा सकता है?

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