लूप/रिकर्सन के साथ मैट्रिक्स में पंक्तियों को मिरर करना?

Question

कुछ मैट्रिक्स को देखते हुए, मुझे मैट्रिक्स में सभी पंक्तियों को दर्पण करने की आवश्यकता है। उदाहरण

लिए

[[2, 1], 
[4, 3]] 

बन जाएगा

[[1, 2], 
[3, 4]] 

मैं (2 एक्स 2) -case लिए यह करने में कामयाब रहे। लेकिन मैं मुसीबत कुछ इस तरह मिरर आ रही हैं:

[[1, 2, 3, 4], 
[1, 2, 3, 4]] 

यह बनने के लिए

[[4, 3, 2, 1], 
[4, 3, 2, 1]] 

मैं साथ छोरों/प्रत्यावर्तन ऐसा करना चाहते हैं। यदि मैं रिकर्सन का उपयोग करता हूं, तो शायद मेरे पास मूलभूत कदम होगा कि आंतरिक अधिकांश तत्व पहले स्वैप हो जाएंगे, और फिर यहां से हम बाहरी तत्वों सहित और उन्हें भी स्वैप करके मैट्रिक्स को बड़ा बना देंगे। हालांकि, मुझे रिकर्सन चरण में परेशानी हो रही है। आंतरिक तत्वों को स्वैप करने के बाद, मैं मैट्रिक्स में आंतरिक अधिकांश तत्वों को शामिल करना चाहता हूं, और उन्हें भी स्वैप करना चाहता हूं, और फिर जब तक हम बाहरी तत्वों तक नहीं पहुंच जाते, तब तक इस तरह जारी रखें। कोड में इसे कैसे कार्यान्वित किया जा सकता है? मैंने अभी तक यह किया है:

matrix = [[1, 2, 3, 4], 
      [1, 2, 3, 4]] 

def mirror(matrix): 
    # This corresponds to the basic step. The two inner most elements get swapped. 
    if len(matrix) == 2: 
     for i in range(len(matrix)): 
      for j in range(len(matrix)): 
       # Store one element in a temporal variable 
       temp = matrix[i][j] 
       matrix[i][j] = matrix[i][len(matrix) - 1] 
       matrix[i][len(matrix)-1] = temp 
       return matrix 

    else: 
     # Recursion step 
     for i in range(len(matrix)): 
      for j in range(len(matrix)): 
       return (matrix + mirror(matrix[(len(matrix) // 2) - 1 : len(matrix)])) 

रिकर्सन चरण गलत है मुझे लगता है। मैंने स्लाइस ऑपरेटर का उपयोग करने की कोशिश की, लेकिन मुझे यकीन नहीं है कि यह सही तरीके से कैसे किया जाना चाहिए। इस समस्या के साथ किसी भी मदद की सराहना की जाएगी।

Answer 1

एक पुनरावर्ती समाधान सरणी पार बस recurse बहुत तुच्छ है, प्रत्येक subarray reversing:

arr= [[2, 1], 
[4, 3]] 

def reve(l): 
    # if we have recursed across all sub arrays just return empty list 
    if not l: 
     return [] 
    # else reverse the first current sublist l[0] and recurse on the remaining sublists 
    return [l[0][::-1]] + reve(l[1:]) 


print(reve(arr)) 
[[1, 2], [3, 4]] 

कौन सा रूप में संक्षेप में लिखा जा सकता है:

def reve(l): 
    return [l[0][::-1]] + reve(l[1:]) if l else [] 

यदि आप यह चाहते थे inplace:

arr = [[1, 2, 3, 4], 
    [1, 2, 3, 4]] 

def reve(l): 
    if not l: 
     return 
    # call inplace list.reverse on each sublist 
    l[0].reverse() 
    return reve(l[1:]) 


reve(arr) 

आउटपुट:

[[4, 3, 2, 1], [4, 3, 2, 1]] 

और ला stly हम हासिल कर सकते हैं कि आप क्या चाहते कोई टुकड़ा करने की क्रिया में सभी विशेष विधि __length__hint साथ iter उपयोग करने के साथ inplace:

def reve(l): 
    if l.__length_hint__() == 0: 
     return 
    sub = next(l) 
    sub.reverse() 
    return reve(l) 


reve(iter(arr)) 

print(arr) 

आउटपुट:

[[4, 3, 2, 1], [4, 3, 2, 1]] 

Answer 2

दरअसल, ऐसा करने का एक और पाइथोनिक तरीका सूची समझ का उपयोग करेगा। आप इसे आसानी से कर सकते हैं:

matrix = [[1, 2, 3, 4], 
     [1, 2, 3, 4]] 
reversed_matrix = (i[::-1] for i in matrix) 

reversed_matrix जनरेटर अभिव्यक्ति होगी। आप सूची समझ में "[]" के साथ "(]" को बदलकर इसे एक सूची में परिवर्तित कर सकते हैं।

i[::-1] यथा-स्थान सरणी टुकड़ा ऑपरेटर

Answer 3

का उपयोग कर दोनों कार्यों map समारोह का उपयोग कर सकते हैं, लेकिन आप भी एक जरूरी for उपयोग कर सकते हैं पराजयों। मेरे रिकर्सिव दृष्टिकोण के बारे में, अन्य कथन सूची के अंतिम और दूसरे तत्वों के बीच सभी मामलों को संदर्भित करता है, जब तक कि पहले तत्व तक नहीं पहुंच जाता है, तब तक उन्हें संयोजित किया जा रहा है।

मेरे पुनरावर्ती दृष्टिकोण:

a = [[1, 2, 3], 
    [5, 6, 7]] 

def mirror(matrix): 
    def revert(row): 
     if len(row) == 1: 
      return [row[0]] 
     else: 
      return [row[-1]] + revert(row[:-1]) # concatenates two lists. 

    return [revert(row) for row in matrix] 

mirror(a) 

मेरे कथात्मक दृष्टिकोण:

def mirror(matrix): 
    def revert(row): 
     return row[::-1] # copies the array in reverse order 

    return list(map(revert, matrix)) #<-for python3, and just map(...) for python2 

mirror(a) 

दोनों कार्यों आउटपुट

[[3, 2, 1], [7, 6, 5]]