ऐरे की मूल बातें और In-Place संचालन
अनुक्रमण और परिवर्तन दोहराइए तथा सामान्य साक्षात्कार-त्रुटियों को समझिए, जैसे सीमा से एक अधिक या कम होना और पुनरावृत्ति के दौरान सूची बदलना।
ऐरे की मूल बातें और In-Place संचालन, CoddyKit पर DSA Interview Prep का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह DSA Interview Prep सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। DSA Interview Prep पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
सन्निहित मेमोरी के रूप में arrays
अंदरूनी रूप से, Python की सूची एक डायनेमिक array पर आधारित होती है — मेमोरी का एक सन्निहित खंड, जहाँ तत्व लगातार पतों पर रखे जाते हैं। यह व्यवस्था index के आधार पर O(1) यादृच्छिक पहुँच देती है: Python तुरंत address = base + index × element_size की गणना करता है। बीच में insertion या deletion करने के लिए उसके बाद के सभी तत्वों को खिसकाना पड़ता है, जिसकी लागत O(n) है। यही असममिति array से जुड़े अधिकांश साक्षात्कारों में होने वाली समझौतों की चर्चाओं का कारण है।
nums = [10, 20, 30, 40, 50]
# O(1) random access
print(nums[2]) # 30
print(nums[-1]) # 50
# O(1) append (amortised)
nums.append(60)
print(nums) # [10,20,30,40,50,60]
# O(n) insert at beginning
nums.insert(0, 0) # shifts all elements right
print(nums) # [0,10,20,30,40,50,60]एक से अधिक: array की क्लासिक त्रुटि
एक से अधिक वाली त्रुटियाँ array की समस्याओं में गलत उत्तरों का सबसे आम स्रोत हैं। Python का 0-आधारित indexing बताता है कि अंतिम मान्य index len(arr) - 1 है। लूप लिखते समय सबसे छोटे मान्य input (n=1 या n=2) के साथ सीमा की स्थिति जाँचकर तय कीजिए कि आपको < चाहिए या <=। सबमिट करने से पहले हमेशा ठोस उदाहरणों से अपनी सीमा की जाँच कीजिए।
def find_max(nums):
# Use len(nums)-1 as last index
max_val = nums[0] # safe if n >= 1
for i in range(1, len(nums)): # start at 1, not 0
if nums[i] > max_val:
max_val = nums[i]
return max_val
print(find_max([3, 1, 4, 1, 5])) # 5
print(find_max([7])) # 7 (single element)
# Would crash if we accessed nums[len(nums)]दो पॉइंटर से उसी स्थान पर उलटना
किसी array को उसी स्थान पर उलटने के लिए विपरीत सिरों से शुरू होने वाले दो पॉइंटर उपयोग किए जाते हैं। वे तब तक अंदर की ओर बढ़ते हुए तत्वों की अदला-बदली करते हैं, जब तक मिल नहीं जाते। इसके लिए O(1) अतिरिक्त स्थान और O(n) समय चाहिए। left < right की शर्त दोनों सम और विषम लंबाइयों के लिए सही परिणाम सुनिश्चित करती है — विषम संख्या में तत्व होने पर बीच का तत्व अपने-आप उसी स्थान पर रहता है।
def reverse_inplace(arr):
left, right = 0, len(arr) - 1
while left < right:
arr[left], arr[right] = arr[right], arr[left]
left += 1
right -= 1
# Space: O(1) Time: O(n)
a = [1, 2, 3, 4, 5]
reverse_inplace(a)
print(a) # [5, 4, 3, 2, 1]
b = [1, 2, 3]
reverse_inplace(b)
print(b) # [3, 2, 1] middle element unchangedकिसी array को उसी स्थान पर घुमाना
किसी array को k स्थान दाईं ओर घुमाने के लिए तीन खंडों को उलटते हुए उसी स्थान पर काम किया जा सकता है: पहले पूरे array को उलटिए, फिर पहले k तत्वों को, और अंत में बचे हुए n-k तत्वों को। इससे O(n) समय और O(1) स्थान मिलता है — स्लाइसिंग और जोड़ने वाले O(n) स्थान के तरीके से कहीं बेहतर। k ≥ n को संभालने के लिए हमेशा k को n के मापांक से घटाकर छोटा कीजिए।
def rotate(nums, k):
n = len(nums)
k %= n # handle k >= n
def rev(l, r):
while l < r:
nums[l], nums[r] = nums[r], nums[l]
l += 1; r -= 1
rev(0, n-1) # reverse all
rev(0, k-1) # reverse first k
rev(k, n-1) # reverse rest
a = [1, 2, 3, 4, 5, 6, 7]
rotate(a, 3)
print(a) # [5, 6, 7, 1, 2, 3, 4]तत्वों को उसी स्थान पर हटाना
डुप्लिकेट या लक्ष्य मानों को उसी स्थान पर हटाने के लिए एक लेखन पॉइंटर उपयोग किया जाता है, जो बताता है कि अगला मान्य तत्व कहाँ लिखा जाना चाहिए। पठन पॉइंटर आगे की ओर स्कैन करता है; जब उसे कोई मान्य तत्व मिलता है, तो वह उसे लेखन स्थान पर कॉपी करता है और दोनों पॉइंटर आगे बढ़ाता है। यह 'remove element', 'remove duplicates from sorted array' और 'move zeroes' जैसी LeetCode समस्याओं का मूल पैटर्न है।
def remove_element(nums, val):
write = 0
for read in range(len(nums)):
if nums[read] != val:
nums[write] = nums[read]
write += 1
return write # new length
nums = [3, 2, 2, 3]
new_len = remove_element(nums, 3)
print(nums[:new_len]) # [2, 2]
nums2 = [0, 1, 2, 2, 3, 0, 4, 2]
new_len2 = remove_element(nums2, 2)
print(nums2[:new_len2]) # [0, 1, 3, 0, 4]शून्यों को स्थानांतरित करना: पढ़ने-लिखने वाला पॉइंटर
ऐरे के सभी शून्य मानों को गैर-शून्य तत्वों का क्रम बनाए रखते हुए अंत में ले जाएँ। पढ़ने-लिखने वाला पॉइंटर तरीका प्रत्येक गैर-शून्य तत्व को लिखने की स्थिति पर रखता है और फिर अंतिम भाग को शून्यों से भरता है। एक वैकल्पिक तरीका शून्यों को पीछे की ओर अदला-बदली करता है और दूसरे भराई चरण के बिना क्रम बनाए रखता है। दोनों में O(n) समय और O(1) स्थान लगता है।
def move_zeroes(nums):
write = 0
# Move all non-zeroes to front
for read in range(len(nums)):
if nums[read] != 0:
nums[write] = nums[read]
write += 1
# Fill rest with zeroes
while write < len(nums):
nums[write] = 0
write += 1
a = [0, 1, 0, 3, 12]
move_zeroes(a)
print(a) # [1, 3, 12, 0, 0]वर्ग करना और Sort को मूल स्थान पर करना
एक क्रमबद्ध पूर्णांक ऐरे दिए जाने पर, जिसके मान ऋणात्मक भी हो सकते हैं, उनके वर्गों का एक क्रमबद्ध ऐरे लौटाएँ। सीधा तरीका पहले वर्ग करता है और फिर क्रमबद्ध करता है: O(n log n)। सर्वोत्तम दो-पॉइंटर तरीका इस तथ्य का लाभ उठाता है कि सबसे बड़े वर्ग क्रमबद्ध इनपुट के किसी एक छोर से आते हैं: सबसे बाएँ और सबसे दाएँ तत्वों के निरपेक्ष मानों की तुलना करें और O(n) समय में परिणाम को दाएँ से बाएँ भरें।
def sorted_squares(nums):
n = len(nums)
result = [0] * n
left, right = 0, n - 1
pos = n - 1 # fill from the right
while left <= right:
l_sq = nums[left] ** 2
r_sq = nums[right] ** 2
if l_sq > r_sq:
result[pos] = l_sq
left += 1
else:
result[pos] = r_sq
right -= 1
pos -= 1
return result
print(sorted_squares([-4, -1, 0, 3, 10]))
# [0, 1, 9, 16, 100]पिवट ढूँढ़ना और विभाजन
डच राष्ट्रीय ध्वज समस्या तीन पॉइंटर का उपयोग करके ऐरे को तीन खंडों में (पिवट से छोटे, बराबर और बड़े) उसी स्थान पर विभाजित करती है। यह त्वरित sort का मुख्य उप-चरण और LeetCode की 'sort रंग' समस्या का समाधान है। निम्न पॉइंटर से पहले के तत्वों के < pivot और उच्च पॉइंटर के बाद के तत्वों के > pivot होने की अपरिवर्तनीयता बनाए रखना एल्गोरिदम को दिशा देता है।
def sort_colors(nums):
# Dutch national flag: 0s, 1s, 2s
low, mid, high = 0, 0, len(nums) - 1
while mid <= high:
if nums[mid] == 0:
nums[low], nums[mid] = nums[mid], nums[low]
low += 1; mid += 1
elif nums[mid] == 1:
mid += 1
else:
nums[mid], nums[high] = nums[high], nums[mid]
high -= 1 # don't advance mid: new nums[mid] unexamined
a = [2, 0, 2, 1, 1, 0]
sort_colors(a)
print(a) # [0, 0, 1, 1, 2, 2]क्रम से गुजरते समय ऐरे तत्वों में बदलाव
आप क्रम से गुजरते समय तत्व मानों में सुरक्षित रूप से बदलाव कर सकते हैं (जैसे, देखे जा चुके तत्व को चिह्नित करने के लिए -1 से गुणा करना), लेकिन for लूप के दौरान सूची की लंबाई कभी न बदलें। एक सुरक्षित कूटबद्धन युक्ति यह है कि एक ही पूर्णांक में अस्थायी रूप से दो मान कूटबद्ध किए जाएँ (जैसे, चिह्न-बिट का उपयोग करके), ताकि अतिरिक्त स्थान आवंटित किए बिना प्रत्येक तत्व के लिए एक अतिरिक्त बूलियन मान का अनुकरण किया जा सके। यह 'ऐरे में से गायब हुई सभी संख्याएँ ढूँढ़ने' जैसी समस्याओं में दिखाई देता है।
def find_disappeared(nums):
# Mark visited by negating the value at the index
for n in nums:
idx = abs(n) - 1
if nums[idx] > 0:
nums[idx] *= -1 # mark as seen
# Indices with positive values are missing
return [i + 1 for i, v in enumerate(nums) if v > 0]
print(find_disappeared([4, 3, 2, 7, 8, 2, 3, 1]))
# [5, 6] -- O(n) time, O(1) extra spaceऐरे साक्षात्कार-पैटर्न जाँच-सूची
किसी भी ऐरे समस्या के लिए कोड लिखने से पहले इस मानसिक जाँच-सूची से गुजरें:
- क्या ऐरे क्रमबद्ध है? (दो पॉइंटर और द्विआधारी खोज संभव होती है)
- क्या तत्वों की सीमा बंधी हुई है (जैसे, 1..n)? (सूचकांक-आधारित युक्तियाँ संभव होती हैं)
- क्या उसी स्थान पर काम करना आवश्यक है? (पढ़ने-लिखने वाला पॉइंटर या अदला-बदली)
- क्या मुझे सभी युग्म चाहिए या केवल एक? (इससे तय होता है कि नेस्टेड लूप स्वीकार्य हैं या नहीं)
- विशेष स्थितियाँ: खाली ऐरे, एक तत्व, सभी समान मान
def max_profit(prices):
# Pattern: single scan, track running minimum
# Time: O(n), Space: O(1)
if not prices: return 0 # edge case: empty
min_price = prices[0]
max_prof = 0
for price in prices[1:]: # start at index 1
max_prof = max(max_prof, price - min_price)
min_price = min(min_price, price)
return max_prof
print(max_profit([7, 1, 5, 3, 6, 4])) # 5
print(max_profit([7, 6, 4, 3, 1])) # 0Kadane का एल्गोरिदम: अधिकतम उप-ऐरे
Kadane का एल्गोरिदम O(n) समय और O(1) स्थान में अधिकतम योग वाले सन्निकट उप-ऐरे को ढूँढ़ता है। प्रत्येक चरण में तय करें कि वर्तमान उप-ऐरे को बढ़ाना है या नया शुरू करना है: current = max(num, current + num)। यदि current + num, केवल num से छोटा है, तो वर्तमान उप-ऐरे हमें नीचे खींच रहा है और हम नए सिरे से शुरू करते हैं। पूरी प्रक्रिया में वैश्विक अधिकतम का अभिलेख रखें।
def max_subarray(nums):
current = global_max = nums[0]
for n in nums[1:]:
current = max(n, current + n) # extend or restart
global_max = max(global_max, current)
return global_max
print(max_subarray([-2, 1, -3, 4, -1, 2, 1, -5, 4]))
# 6 (subarray [4, -1, 2, 1])
print(max_subarray([-1, -2, -3]))
# -1 (all negative: take the least negative)त्वरित जाँच
इस पाठ में डेटा संरचनाएँ & एल्गोरिदम — कोडिंग साक्षात्कार की तैयारी से जुड़ी अवधारणाओं की अपनी समझ की जाँच करें।
पाठ का पुनरावलोकन
इस पाठ में आपने सीखा: ऐरे O(1) का यादृच्छिक अभिगम, लेकिन बीच में प्रविष्टि और विलोपन के लिए O(n) समय देते हैं — इस असममिति की जानकारी एल्गोरिदम के चयन का मार्गदर्शन करती है, पढ़ने-लिखने वाला पॉइंटर पैटर्न O(n) समय और O(1) स्थान में तत्वों को हटाता या मानों को उसी स्थान पर ले जाता है, और चिह्न-बिट कूटबद्धन तथा सूचकांक को चिह्न की तरह उपयोग करना उन समस्याओं के लिए O(1) स्थान वाले समाधान संभव बनाता है जिनमें अन्यथा सहायक ऐरे की आवश्यकता होती। अब हम प्रिफिक्स योग और क्रमिक कुल का अध्ययन करेंगे।
एआई शिक्षक के साथ Python सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “ऐरे की मूल बातें और In-Place संचालन” पाठ निःशुल्क है?
हाँ — DSA Interview Prep अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “ऐरे की मूल बातें और In-Place संचालन” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। DSA Interview Prep पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“ऐरे की मूल बातें और In-Place संचालन” में मैं क्या सीखूँगा?
अनुक्रमण और परिवर्तन दोहराइए तथा सामान्य साक्षात्कार-त्रुटियों को समझिए, जैसे सीमा से एक अधिक या कम होना और पुनरावृत्ति के दौरान सूची बदलना। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ DSA Interview Prep का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या DSA Interview Prep शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर DSA Interview Prep शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।
“ऐरे की मूल बातें और In-Place संचालन” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस DSA Interview Prep पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर DSA Interview Prep पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- ऐरे की मूल बातें और In-Place संचालन
- उपसर्ग योग और संचयी योग
- दो संकेतक: विपरीत छोर
- दो संकेतक: धीमा और तेज़