तो मैं प्रोग्रामिंग के लिए नया हूं, और मुझे सीमा त्रुटियों से बाहर इंडेक्स में परेशानी हो रही है। त्वरित उदाहरण:

मेरे पास एक सूची है, lst = (5,7,8,9,10)

मैं प्रत्येक सम संख्या, और प्रत्येक संख्या को सम संख्या के दाईं ओर हटाना चाहता हूं।

मैं प्रत्येक सम संख्या, 'i' की अनुक्रमणिका प्राप्त करके और lst[i] और lst [i+1] को हटाकर इस समस्या का समाधान करूंगा। यह तब काम नहीं करेगा जब अंतिम संख्या सम हो क्योंकि सूची में अंतिम तत्व के बाद कोई lst [i+1] नहीं है।

मैंने इस मुद्दे पर कई बुनियादी समस्याओं पर काम किया है जिन पर मैं काम कर रहा हूं। इसे हल करने का मेरा दृष्टिकोण शायद गलत है, इसलिए मैं जानना चाहूंगा:

  1. मैं इस तरह से समस्या का समाधान कैसे कर सकता/सकती हूं, चाहे वह कुशल हो या नहीं?
  2. इस समस्या को हल करने का सबसे कारगर तरीका क्या होगा?
0
jra 22 फरवरी 2020, 22:17
2
lst = (5,7,8,9,10) यह एक टपल है, सूची नहीं।
 – 
AMC
22 फरवरी 2020, 22:36
क्षमा करें, मतलब lst = [5,7,8,9,10]
 – 
jra
22 फरवरी 2020, 23:56

3 जवाब

क्लब में आपका स्वागत है! प्रोग्रामिंग बहुत मजेदार है और कुछ ऐसा जिसे आप हमेशा वृद्धिशील प्रगति के साथ सुधार सकते हैं। मैं अपने उत्तर के साथ संपूर्ण होने की कोशिश करने जा रहा हूं।

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

arr = [5, 7, 8, 9, 10]

# If you want to access the first element of the array
# then you would use the 0 index. If you want the Second
# element you use index 1.

print(arr[0]) # prints 5 or the 1st element
print(arr[1]) # prints 7 or the 2nd element

मैं आपकी स्टैंड लूपिंग तकनीक का उपयोग नहीं करूंगा जैसे कि इस मामले में या जबकि आप तत्वों को हटा रहे हैं क्या आप सरणी के लिए जा रहे हैं। यदि आप आइटम को हटाते हैं जैसे आप लूप कर रहे हैं तो आप सरणी की लंबाई बदल रहे हैं।

इसके बजाय, आप लूपिंग से एक नई सरणी बना सकते हैं और केवल इस नए सरणी में विषम मान जोड़ या जोड़ सकते हैं।

arr = [5, 7, 8, 9, 10]
new_arr = []

for idx, val in enumerate(arr):
    if idx % 2 == 1:
        new_arr.append(val)
return new_arr # yields [7,9] or this process creates a new array of odd elements

इसके अलावा, याद रखें कि जब आप लूप के माध्यम से अनुक्रमित करते समय [i+1] का उपयोग कर रहे हैं, तो यह समझ में आता है कि लूप को एक तत्व को जल्दी से बंद कर दें ताकि इंडेक्स रेंज त्रुटि से बाहर न हो।

ऐसा करें (कोई त्रुटि नहीं)

for idx in range(len(arr)-1):
    # pseudocode
    print(arr[i] + arr[i+1])

इसके बजाय (सूचकांक त्रुटि से बाहर)। इसका कारण यह है कि अंतिम तत्व पर यदि आप अंतिम अनुक्रमणिका में 1 जोड़ने का प्रयास करते हैं और फिर उस मान तक पहुँच प्राप्त करते हैं जो मौजूद नहीं है तो एक त्रुटि वापस आ जाएगी:

for idx in range(len(arr)):
    # pseudocode
    print(arr[i] + arr[i+1])
arr = [5, 7, 8, 9, 10]
# if you try to access arr[5]
# you will get an error because the index 
# and element do not exist
# the last element of arr is arr[4] or arr[-1]
arr[5] # yields an out of index error

आपके लक्ष्य को पूरा करने के लिए कई पाइथोनिक (लगभग एक बोलचाल के वाक्यांश की तरह) हैं जो नीचे अधिक कुशल हैं।

आप सम संख्या तत्वों को हटाने के लिए स्लाइसिंग, स्पेसिंग और डेल (स्टेटमेंट हटाएं) का उपयोग कर सकते हैं

>>> arr = [5, 7, 8, 9, 10]
>>> del arr[::2] # delete even numbers # if you wanted to delete odd numbers del arr[1::2]
>>> arr
[7, 9]

या सम संख्याओं को फ़िल्टर करने के लिए कुछ सशर्त के माध्यम से लूपिंग करते समय एक नई सूची बनाने के लिए एक सूची समझ:

new_arr = [elem for idx, elem in enumerate(arr) if idx % 2 == 0]

% ऑपरेटर का उपयोग यह देखने के लिए किया जाता है कि विभाजन से शेष है या नहीं। तो अगर idx 10 है। तो 10% 2 == 0 सत्य है क्योंकि 2 10 को पांच बार विभाजित करने में सक्षम है और शेष 0 है। इसलिए, तत्व सम है। यदि आप विषम के लिए जाँच कर रहे थे तो स्थिति यह होगी:

idx % 2 == 1

आप इस महान स्टैक ओवरफ़्लो पोस्ट यहां

1
Kevin Carr 22 फरवरी 2020, 23:15

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

यहां एक उदाहरण दिया गया है कि आप जो खोज रहे हैं उसे कैसे पूरा कर सकते हैं:

myList = [5, 7, 8, 9, 10]

# use list comprehension to get indexes of even numbers into a list.
# num % 2 uses the modulus operator to find numbers divisible by 2
# with a remainder of 0.
even_number_indexes = [idx for idx, num in enumerate(myList) if num % 2 == 0]
# even_number_indexes: [2, 4]

# sort our new list descending
even_number_indexes.reverse()
# even_number_indexes: [4, 2]

# iterate over even_number_indexes and delete index and index + 1
# from myList by specifying a range [index:index + 2]
for index in even_number_indexes:
    del myList[index:index + 2]


print(myList)

आउटपुट: [5, 7]

1
Alec Thomas 23 फरवरी 2020, 02:34
यार, यह मुझे भ्रमित कर रहा है !!! धन्यवाद, क्या आप मुझे वह कोड समझा सकते हैं?
 – 
jra
23 फरवरी 2020, 00:06

आप जांच सकते हैं कि i+1 सूची की लंबाई (संपादित करें: या इसके बराबर) से अधिक है, और यदि यह है, तो कोड निष्पादित नहीं करें।

आप इसे एक कोशिश/ब्लॉक को छोड़कर भी संभाल सकते हैं।

हल करने की इस पद्धति की दक्षता के रूप में, मुझे ठीक लगता है। इस दृष्टिकोण में एक गलती यह है कि लोग इसे संशोधित करते समय सूची में पुनरावृति करने का प्रयास करते हैं, जिससे अज्ञात त्रुटियां हो सकती हैं। यदि आप remove() फ़ंक्शन का उपयोग कर रहे हैं, तो संभवतः आप इसे सूची की एक प्रति के साथ करना चाहते हैं।

0
Audemed 22 फरवरी 2020, 22:53
1
क्या यह "इससे बड़ा या इसके बराबर" नहीं होना चाहिए?
 – 
Hymns For Disco
22 फरवरी 2020, 22:47