कल्पना करें कि कोई AI संदिग्ध गतिविधि के लिए लाइव वीडियो फ़ीड देख रहा है। वह हर सेकंड पूरी रिकॉर्डिंग फिर से नहीं देख सकता। उसे धारा पर ध्यान की एक विंडो सरकानी होती है और बस उतना संदर्भ रखना होता है जितना ज़रूरी है। क्रमिक डेटा के लिए दो पॉइंटर और स्लाइडिंग विंडो पैटर्न ठीक यही करते हैं।
दोनों तकनीकें बलपूर्वक O(n²) स्कैन को सुंदर O(n) पास में बदल देती हैं।
किसी क्रम में दो संदर्भ रखें और उन्हें किसी नियम के अनुसार आगे बढ़ाएँ। इसके दो मुख्य रूप हैं।
एक पॉइंटर हर सिरे पर रखें और उन्हें भीतर की ओर बढ़ाएँ। यह क्रमबद्ध डेटा के लिए बिल्कुल उपयुक्त है।
क्लासिक समस्या - जोड़े का योग: क्रमबद्ध ऐरे दिया है। ऐसे दो नंबर ढूँढें जिनका योग लक्ष्य के बराबर हो।
function pairSum(arr, target):
left = 0
right = arr.length - 1
while left < right:
sum = arr[left] + arr[right]
if sum == target: return (left, right)
if sum < target: left += 1
else: right -= 1
return null
ऐरे क्रमबद्ध है, इसलिए left को दाईं ओर ले जाने से योग बढ़ता है और right को बाईं ओर ले जाने से योग घटता है। इसी से गारंटी मिलती है कि कोई वैध जोड़ा छूटेगा नहीं।
दोनों पॉइंटर आगे बढ़ते हैं, लेकिन अलग-अलग गति से। यह विभाजन या चक्र पहचान के लिए उपयोगी है।
उदाहरण - उसी जगह डुप्लिकेट हटाना: धीमा पॉइंटर लिखने की जगह बताता है। तेज़ पॉइंटर आगे स्कैन करता है।
function removeDuplicates(arr):
slow = 0
for fast in 1..arr.length - 1:
if arr[fast] != arr[slow]:
slow += 1
arr[slow] = arr[fast]
return slow + 1
क्रमबद्ध ऐरे पर पास आते दो-पॉइंटर तरीके में, जब वर्तमान योग लक्ष्य से कम हो तो आपको क्या करना चाहिए?
साइन इन करें चर्चा में शामिल होने के लिए
स्लाइडिंग विंडो आकार k की सटीक या बदलती लंबाई की एक सतत उप-श्रृंखला बनाए रखती है। यह हर बार शुरू से फिर गणना करने के बजाय योग जैसी सूचनाएँ धीरे-धीरे अपडेट करती है।
ऐरे पर ठीक k एलिमेंट की विंडो सरकाएँ।
उदाहरण - किसी भी k लगातार एलिमेंट का अधिकतम योग:
function maxSubarraySum(arr, k):
windowSum = sum(arr[0..k-1])
best = windowSum
for i in k..arr.length - 1:
windowSum += arr[i] - arr[i - k]
best = max(best, windowSum)
return best
हर चरण में विंडो में आने वाला नया एलिमेंट जोड़ा जाता है और बाहर जाने वाला एलिमेंट घटाया जाता है। हर चाल O(1) है।
अधिक डेटा शामिल करने के लिए विंडो फैलाएँ, फिर जब कोई सीमा टूटे तो उसे छोटा करें।
उदाहरण - दोहराए गए अक्षरों के बिना सबसे लंबी सबस्ट्रिंग:
function longestUnique(s):
seen = {}
left = 0
best = 0
for right in 0..s.length - 1:
if s[right] in seen and seen[s[right]] >= left:
left = seen[s[right]] + 1
seen[s[right]] = right
best = max(best, right - left + 1)
return best
| पैटर्न | AI उपयोग | |---------|------------| | निश्चित विंडो | पिछले k सेंसर रीडिंग पर असामान्यता पहचान | | बदलती विंडो | सभी क्वेरी कीवर्ड रखने वाला सबसे छोटा टेक्स्ट खंड ढूँढना (सर्च इंजन) | | पास आते पॉइंटर | क्रमबद्ध एम्बेडिंग आयामों में कुशल निकटतम-पड़ोसी जाँच | | एक दिशा वाले पॉइंटर | कई रिट्रीवल मॉडल से आए क्रमबद्ध परिणामों की सूचियाँ मिलाना |
दिए गए मान से अधिक योग वाली सबसे छोटी उप-सरणी खोजने के लिए आप कौन सा पैटर्न चुनेंगे?
बलपूर्वक नेस्टेड लूप को दो-पॉइंटर या स्लाइडिंग-विंडो समाधान में बदलने पर सामान्यतः कौन सी समय जटिलता मिलती है?