मेरे पास 2 सूचियां हैं

  • [ए, बी, सी, डी, ई, एफ] - पहली सूची
  • [एक्स, एक्स, एक्स, एक्स, एक्स, एक्स] - दूसरी सूची

मैं पहली सूची का अंतिम तत्व लेना चाहता हूं और यदि दूसरी सूची में कोई तत्व हैं तो उन्हें बाईं ओर ले जाएं और तत्व को अंतिम के रूप में जोड़ें।

  1. [ए, बी, सी, डी, ई, एफ]
  2. [एक्स, एक्स, एक्स, एक्स, एक्स, एक्स]
  3. [ए, बी, सी, डी, ई]
  4. [एक्स, एक्स, एक्स, एक्स, एक्स, एफ]
  5. [ए बी सी डी]
  6. [एक्स, एक्स, एक्स, एक्स, एफ, ई]

जब तक पहली सरणी में केवल पहला तत्व न हो, तो यह यहां रुक जाएगा:

  • [ए]
  • [एक्स, एफ, ई, डी, सी, बी]

मैं पाइथन के लिए काफी नया हूं, मैं वास्तव में कुछ मदद की सराहना करता हूं

1
Filgum0326 16 जिंदा 2022, 17:41
1
मुझे यह बिल्कुल समझ में नहीं आया... क्या दूसरी सूची शुरू करने के लिए खाली है या इसमें 6 तत्व हैं? यदि बाद वाला सत्य है, तो परिणामी सूची में केवल 5 तत्व क्यों हैं?
 – 
Schottky
16 जिंदा 2022, 17:47
2
क्या आपने पायथन में कोड लिखने की कोशिश की है ??
 – 
akm
16 जिंदा 2022, 17:48
शुरुआत में दूसरी सूची में छह तत्व होते हैं, मैं एक्स को रिक्त प्रतीक के रूप में उपयोग करता हूं
 – 
Filgum0326
16 जिंदा 2022, 17:50
मुझे समझ नहीं आ रहा है कि मैं किसके साथ शुरुआत करूं
 – 
Filgum0326
16 जिंदा 2022, 17:50
तो यदि पहले ए, बी, सी, डी, ई, एफ और उदाहरण के लिए 1,2,3,4,5,6 के साथ विलय हो तो परिणाम 1, एफ, ई, डी, सी, बी होना चाहिए? या 1,2,3,4,5, एफ, ई, डी, सी, बी?
 – 
whale_steward
16 जिंदा 2022, 17:54

7 जवाब

सबसे बढ़िया उत्तर

इंडेक्स असाइनमेंट के साथ सूची pop का उपयोग करें

>>> l1 = ['A','B','C','D','E','F']
>>> l2 = ['X' for _ in range(len(l1))]
>>> print(l1)
['A', 'B', 'C', 'D', 'E', 'F']

>>> print(l2)
['X', 'X', 'X', 'X', 'X', 'X']

>>> for idx in range(len(l1)-1):
    p = l1.pop()
    l2[idx+1] = p
>>> print(l1)

['A']

>>> print(l2)

['X', 'F', 'E', 'D', 'C', 'B']

0
Rajarshi Ghosh 16 जिंदा 2022, 18:13
for i in range(len(l)-1,0,-1) जैसे लूप को चलाने से अपेक्षित परिणाम मिलेगा।
 – 
Abhishek
16 जिंदा 2022, 18:10
अपेक्षित आउटपुट ['X', 'F', 'E', 'D', 'C', 'B'] होना चाहिए।
 – 
akm
16 जिंदा 2022, 18:11
धन्यवाद @akm - इसे सही किया
 – 
Rajarshi Ghosh
16 जिंदा 2022, 18:15

आप इसके लिए लूप के लिए उपयोग कर सकते हैं। और आप -1 को इंडेक्स वैल्यू के रूप में उपयोग करके अंतिम तत्वों तक पहुंच सकते हैं।

1
Gobind Singh 16 जिंदा 2022, 17:52

ये कोशिश करें :

l = ['A','B','C','D','E','F']
d = ['X', 'X', 'X', 'X', 'X','X']


for i in range(len(l)-1,0,-1):
    t = l.pop()
    d[-i] = t

print(l)
print(d)

['A'] ['X', 'F', 'E', 'D', 'C', 'B']

0
Abhishek 16 जिंदा 2022, 18:09

मैं इसे इस तरह से कर सकता हूं।

first = ['A','B','C','D','E','F']
second = ['X1','X2','X3','X4','X5','X6']

print(first)
print(second)

while True:
  if len(first) > 1:
    lastElement = first[-1]
    first.remove(lastElement)
    second.append(lastElement)
    second.remove(second[0])
    print(first)
    print(second)

मैंने 'X' में एक नंबर जोड़ा है ताकि आप देख सकें कि वे कैसे चलते हैं। मैंने सूची के अंतिम तत्व को एक चर में सहेजने के लिए [-1] का उपयोग किया, और फिर मैंने हटाने() के साथ हटा दिया। उसी तरह मैं दूसरी सूची में संलग्न विधि के साथ जोड़ रहा था और पहले तत्व को [0] से हटा रहा था। जैसा कि मैंने आपके उदाहरण में देखा, आप [एफ, ई, डी, सी, बी] के साथ समाप्त करते हैं। इस मामले में आप सूची को ऑर्डर करने के लिए विधि .sort() का उपयोग कर सकते हैं। यह आउटपुट है।

['A', 'B', 'C', 'D', 'E', 'F']
['X1', 'X2', 'X3', 'X4', 'X5', 'X6']
['A', 'B', 'C', 'D', 'E']
['X2', 'X3', 'X4', 'X5', 'X6', 'F']
['A', 'B', 'C', 'D']
['X3', 'X4', 'X5', 'X6', 'F', 'E']
['A', 'B', 'C']
['X4', 'X5', 'X6', 'F', 'E', 'D']
['A', 'B']
['X5', 'X6', 'F', 'E', 'D', 'C']
['A']
['X6', 'F', 'E', 'D', 'C', 'B']
0
Guerra09 16 जिंदा 2022, 18:11

आप इस तरह से अजगर के इनबिल्ट लिस्ट फंक्शन का उपयोग करके पूरा काम कर सकते हैं।

list1 = ['A', 'B', 'C', 'D', 'E', 'F']
list2 = ['X'] * len(list1)

for i in range(len(list) - 1, 0, -1):
    item = list1.pop()      # Pop the last item of the first list
    list2.append(item)   # Append it to the end of the second list
    list2.remove(0)        # Shift once
    print(list1)                # For Debug
    print(list2)
0
akm 16 जिंदा 2022, 18:12

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

for i in range(len(list_1)):  # loop over every element of the list
    if len(list_1) == 1:   # when there is only one element left, break from the loop
        break
    else:
        list_2 = list_2[1:len(list_2)] + ['X'] # shift the list one to the left
        list_2[len(list_2) - 1] = list_1.pop() # insert the element at the last position

अब थोड़ा अवलोकन करने पर, आप देख सकते हैं कि अंतिम दो चरण बेमानी हैं। आप सबसे पहले एक 'X' को अंतिम स्थिति में केवल उस तत्व से बदलने के लिए सम्मिलित करते हैं जिसे आप वास्तव में वहां रखना चाहते हैं। तो हम इसे बदलकर और अगली पंक्ति से परिणाम को रेखांकित करके इसे ठीक कर सकते हैं:

for i in range(len(list_1)):
    if len(list_1) == 1:
        break
    else:
        # shift the list and insert the last element
        list_2 = list_2[1:] + [list_1.pop()]

मैंने इस तथ्य का भी उपयोग किया है कि [1:len(list_2)] - यानी सूचकांक 1 से सूची के अंत तक - को केवल [1:] के रूप में फिर से लिखा जा सकता है। आपको अंतिम तत्व को स्पष्ट रूप से लिखने की आवश्यकता नहीं है।

अब तक सब ठीक है। अब हम इस तथ्य का और उपयोग कर सकते हैं कि if len(list_1) == 1 वास्तव में केवल अंतिम तत्व पर होता है। तो दूसरे शब्दों में, आप केवल फॉर-लूप में अंतिम तत्व को छोड़ सकते हैं और बस एक बार कम लूप कर सकते हैं:

for i in range(len(list_1) - 1):  # only iterate len(list_1) - 1 times
    # shift the list and insert the last element
    list_2 = list_2[1:] + [list_1.pop()]

अब एक बहुत ही 'पायथोनिस्टिक' विचार यह है कि जब भी आप range(len(...)) की पंक्तियों में कुछ लिखते हैं, तो आप कुछ गलत कर रहे होते हैं। और, वास्तव में, इस अभिव्यक्ति को और भी सरल बनाया जा सकता है। ध्यान दें कि हम ठीक len(list_1) - 1 बार पॉप करते हैं। कुछ सूची हेरफेर के साथ, इसे फिर से लिखा जा सकता है

list_1, temp_list = [list_1[0]], list_1[1:]  # list_1 contains now only the first element, temp_list contains all others
list_2[:len(list_1) - len(list_2):-1] = temp_list  # use negative indexing to fill list_2 up to the desired position

लेकिन यह और बेहतर हो जाता है। हम पंक्ति 1 और 2 को निम्नलिखित से जोड़ सकते हैं:

list_1, list_2[:len(list_1) - len(list_2):-1] = [list_1[0]], list_1[1:]

अब इस वन-लाइनर में इसका आकर्षण हो सकता है लेकिन यह कम पठनीयता पर आता है। तो अपनी पसंदीदा शैली चुनें

0
Schottky 16 जिंदा 2022, 18:22

अगर मैं समझ गया हूं, तो यह अय्यूब बना सकता है:

L1 = ["a","b","c","d","e"]
L2 = ["X","X","X","X","X"]

TMP = L1[:]

for i, elmt in enumerate(TMP):
    L2[len(TMP)-i-1] = TMP[i]
    L1.pop(0)


print(L1)
print(L2)

आउटपुट:

[]
['e', 'd', 'c', 'b', 'a']
0
SorousH Bakhtiary 16 जिंदा 2022, 18:49