Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> Python

पायथन में घिरे हुए क्षेत्र (Surrounded Regions)

मान लीजिए हमारे पास X और O वाला एक 2D बोर्ड है। X से घिरे सभी क्षेत्रों को कैप्चर करें। एक क्षेत्र को उस घिरे हुए क्षेत्र में सभी O को X में बदलकर कैप्चर किया जाता है।

XXXX
XOOX
XXOX
XOXX

चलाने के बाद आउटपुट होगा

XXXX
XXXX
XXXX
XOXX

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

  • यदि बोर्ड मौजूद नहीं है, तो खाली बोर्ड लौटाएं

  • i को 0 से पंक्तियों की संख्या - 1 तक की रेंज में -

    • यदि board[i, 0] = 'O', तो make_one(board, i, 0)

    • यदि board[i, पंक्ति की लंबाई - 1] = 'O', तो make_one(board, i, पंक्ति की लंबाई - 1)

  • i को 0 से कॉलम की संख्या - 1 तक की रेंज में -

    • यदि board[0, i] = 'O', तो make_one(board, 0, i)

    • यदि board[पंक्ति की संख्या - 1, i] = 'O', तो make_one(board, पंक्ति की संख्या - 1, i)

  • i को 0 से पंक्तियों की संख्या तक की रेंज में

    • j को 0 से कॉलम की संख्या तक की रेंज में

      • यदि board[i, j] = 'O', तो board[i, j] = 'X', अन्यथा 1 के लिए board[i, j] = 'O'

  • make_one इस तरह होगा -

  • यदि i < 0 या j < 0 या i >= पंक्ति संख्या या j >= कॉलम संख्या या board[i, j] = 'X' या board[i, j] = '1', तो लौट जाएं

  • board[i, j] := 1

  • make_one(board, i + 1, j), make_one(board, i - 1, j), make_one(board, i, j + 1), make_one(board, i, j - 1) कॉल करें

यह एल्गोरिदम बॉर्डर से जुड़े 'O' को पहले मार्क करता है, फिर बाकी को 'X' में बदल देता है।

बेहतर समझ के लिए निम्न कार्यान्वयन देखें -

उदाहरण

class Solution(object):
    def solve(self, board):
        """
        :type board: List[List[str]]
        :rtype: None Do not return anything, modify board in-place instead.
        """
        if not board:
            return board
        for i in range(len(board)):
            if board[i][0] == 'O':
                self.make_one(board, i, 0)
            if board[i][len(board[0]) - 1] == 'O':
                self.make_one(board, i, len(board[0]) - 1)
        for i in range(len(board[0])):
            if board[0][i] == 'O':
                self.make_one(board, 0, i)
            if board[len(board) - 1][i] == 'O':
                self.make_one(board, len(board) - 1, i)
        for i in range(len(board)):
            for j in range(len(board[i])):
                if board[i][j] == 'O':
                    board[i][j] = 'X'
                elif board[i][j] == '1':
                    board[i][j] = 'O'

    def make_one(self, board, i, j):
        if i < 0 or j < 0 or i >= len(board) or j >= len(board[0]) or board[i][j] == 'X' or board[i][j] == '1':
            return
        board[i][j] = '1'
        self.make_one(board, i + 1, j)
        self.make_one(board, i - 1, j)
        self.make_one(board, i, j + 1)
        self.make_one(board, i, j - 1)

इनपुट

[["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]

आउटपुट

[["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]]
  1. मैट्रिक्स में पूरी तरह से घिरे हुए द्वीपों की संख्या गिनने का पायथन प्रोग्राम मैट्रिक्स में पूरी तरह से घिरे हुए द्वीपों की संख्या गिनने का पायथन प्रोग्राम

    मान लीजिए हमारे पास एक बाइनरी मैट्रिक्स है। जहां 1 भूमि दर्शाता है और 0 पानी दर्शाता है। जैसा कि हम जानते हैं एक द्वीप 1 का समूह है जो एक साथ जुड़े हुए हैं जिसकी परिधि पानी से घिरी हुई है। हमें पूरी तरह से घिरे हुए द्वीपों की संख्या ढूंढनी है। उदाहरण के लिए, यदि इनपुट इस तरह है: तो आउटपुट 2 होगा,

  1. पायथन में बोर्ड को वर्गों में काटने की न्यूनतम लागत पायथन में बोर्ड को वर्गों में काटने की न्यूनतम लागत

    मान लीजिए हमारे पास लंबाई p और चौड़ाई q का एक बोर्ड है। हमें इस बोर्ड को p*q वर्गों में तोड़ना है ताकि तोड़ने की लागत न्यूनतम हो। प्रत्येक किनारे के लिए काटने की लागत दी गई है। इसलिए, यदि इनपुट X_slice = [3,2,4,2,5], Y_slice = [5,2,3] है, तो आउटपुट 65 होगा। समाधान दृष्टिकोण इसे हल करने के लिए हम न

  1. पायथन में issuperset() फंक्शन पायथन में issuperset() फंक्शन

    इस लेख में, हम पायथन में issuperset() और विभिन्न क्षेत्रों में इसके कार्यान्वयन के बारे में जानेंगे।यह मेथड बूलियन True वापस करता है यदि सेट B के सभी तत्व सेट A के सभी तत्वों को समाहित करते हैं जिसे तर्क के रूप में पारित किया जाता है और झूठा वापस करता है यदि A के सभी तत्व B में मौजूद नहीं हैं।इसका म