कॉलम इंडेक्स खोजने के लिए प्रोग्राम जहां सबसे ज्यादा 1 छोड़ दिया गया है पाइथन में बाइनरी मैट्रिक्स में मौजूद है?

मान लीजिए कि हमारे पास 2D बाइनरी मैट्रिक्स है। यहां प्रत्येक पंक्ति को आरोही क्रम में क्रमबद्ध किया जाता है, जिसमें 0s 1s से पहले आते हैं, हमें 1 के मान के साथ सबसे बाईं ओर का कॉलम इंडेक्स खोजना होगा। यदि ऐसा कोई परिणाम नहीं है, तो -1 लौटाएं।

तो, अगर इनपुट पसंद है

तो आउटपुट 2 होगा, क्योंकि दूसरे कॉलम ने पूरे मैट्रिक्स में सबसे ज्यादा 1 छोड़ा है।

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे:

• अगर मैट्रिक्स खाली है, तो

  • वापसी -1

• N :=मैट्रिक्स की पंक्ति गणना

• एम:=मैट्रिक्स की कॉलम गिनती

• मैं:=0, जे:=एम - 1

• सबसे बाईं ओर :=-1

• जबकि मैं <एन और जे>=0, करते हैं

  • यदि मैट्रिक्स [i, j] 0 के समान है, तो

    • मैं :=मैं + 1

  • अन्यथा,

    • सबसे बाईं ओर :=j

    • जे:=जे - 1

• सबसे बाईं ओर लौटें

उदाहरण

class Solution:
   def solve(self, matrix):
      if not matrix or not matrix[0]:
         return -1

      N = len(matrix)
      M = len(matrix[0])

      i = 0
      j = M - 1

      leftmost = -1

      while i < N and j >= 0:
         if matrix[i][j] == 0:
            i += 1
         else:
            leftmost = j
            j -= 1

      return leftmost

ob = Solution()
matrix = [
   [0, 0, 0, 1],
   [0, 0, 1, 1],
   [0, 0, 1, 1],
   [0, 0, 1, 0]
]
print(ob.solve(matrix))

इनपुट

[
[0, 0, 0, 1],
[0, 0, 1, 1],
[0, 0, 1, 1],
[0, 0, 1, 0] ]

आउटपुट

2