k दिनों के बाद जेल की कोठरियों की स्थिति ज्ञात करने का पायथन प्रोग्राम

मान लीजिए हमारे पास एक बाइनरी सूची (सूची में 1 और 0) और एक मान k है। nums में प्रत्येक मान एक जेल कोठरी की स्थिति को दर्शाता है जहां 1 भरी हुई कोठरी दर्शाता है और 0 खाली कोठरी दर्शाता है। प्रत्येक दिन जब एक कोठरी के दो आसन्न कोठरी या तो दोनों भरी हुई हों या दोनों खाली हों, तो वह भरी हुई हो जाती है। अन्यथा, यह खाली हो जाती है। तो हमें k दिनों के बाद जेल की कोठरियों की स्थिति ढूंढनी है।

उदाहरण के लिए, यदि इनपुट nums = [1, 0, 1, 0, 0, 0, 0, 0] k = 1 है, तो आउटपुट [0, 1, 1, 0, 1, 1, 1, 0] होगा, क्योंकि हम देख सकते हैं कि पहला और अंतिम इंडेक्स कभी भरे नहीं हो सकते क्योंकि उनके कभी 2 पड़ोसी नहीं हो सकते।

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

• एक फ़ंक्शन next_day_state() परिभाषित करें। यह cells लेगा
• new_cells := cells की एक प्रति
• new_cells[0] := 0, new_cells[7] := 0
• j को 1 से 6 तक के लिए, करें
  • यदि cells[j - 1], cells[j + 1] के समान है, तो
    • new_cells[j] := 1
  • अन्यथा,
    • new_cells[j] := 0
• new_cells लौटाएं
• मुख्य विधि से निम्न करें:
• seen := एक नया मैप
• flag := असत्य, i := 0
• जब तक i < N, करें
  • ns := next_day_state(cells)
  • यदि ns seen नहीं है, तो
    • ns को seen के रूप में चिह्नित करें
  • अन्यथा,
    • flag := सत्य
    • लूप से बाहर निकलें
  • cells := ns
  • i := i + 1
• यदि flag सत्य है, तो
  • N := N mod (देखे गए आइटम की संख्या)
  • i := 0
  • जब तक i < N शून्येतर है, करें
    • ns := next_day_state(cells)
    • i := i + 1
    • cells := ns
• cells लौटाएं

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

उदाहरण

import copy
class Solution:
    def next_day_state(self, cells):
        new_cells = copy.copy(cells)
        new_cells[0] = 0
        new_cells[7] = 0
        for j in range(1, 7):
            if cells[j - 1] == cells[j + 1]:
                new_cells[j] = 1
            else:
                new_cells[j] = 0
        return new_cells
    def solve(self, cells, N):
        seen = dict()
        flag, i = False, 0
        while i < N:
            ns = self.next_day_state(cells)
            if tuple(ns) not in seen:
                seen[tuple(ns)] = True
            else:
                flag = True
                break
            cells = ns
            i += 1
        if flag:
            N = N % len(seen)
            i = 0
            while i < N:
                ns = self.next_day_state(cells)
                i += 1
                cells = ns
        return cells

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

इनपुट

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

आउटपुट

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