पायथन में एक बार दी गई दिशा को खिसकाने के बाद अगली बोर्ड स्थिति खोजने का कार्यक्रम

मान लीजिए कि हमारे पास प्रारंभिक बोर्ड का प्रतिनिधित्व करने वाला 2048 गेम बोर्ड है और स्वाइप दिशा का प्रतिनिधित्व करने वाली एक स्ट्रिंग दिशा है, हमें अगली बोर्ड स्थिति ढूंढनी है। जैसा कि हम 2048 के खेल में जानते हैं, हमें संख्याओं का 4 x 4 बोर्ड दिया जाता है (उनमें से कुछ खाली हैं, जिन्हें यहां 0 के साथ दर्शाया गया है) जिसे हम 4 दिशाओं में से किसी में भी स्वाइप कर सकते हैं ("यू", "डी", "एल", या "आर")। जब हम स्वाइप करते हैं, तो सभी संख्याएँ उस दिशा में जहाँ तक संभव हो चलती हैं और समान आसन्न संख्याओं को ठीक एक बार जोड़ दिया जाता है।

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

दिशा ="एल", तो आउटपुट होगा

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

• यदि दिशा "R" के समान है, तो

  • बोर्ड :=बोर्ड को घड़ी की विपरीत दिशा में दो बार घुमाएं

• अन्यथा जब दिशा "U" के समान हो, तब

  • बोर्ड :=बोर्ड को घड़ी की विपरीत दिशा में एक बार घुमाएं

• अन्यथा जब दिशा "D" के समान हो, तो

  • बोर्ड :=बोर्ड को घड़ी की विपरीत दिशा में तीन बार घुमाएं

• मेरे लिए 0 से 3 की सीमा में, करें

  • पंक्ति:=बोर्ड पर सभी गैर-शून्य तत्वों की सूची[i]

  • j के लिए 0 से 2 की सीमा में, करें

    • अगर j + 1 <पंक्ति और पंक्ति का आकार [j] पंक्ति [j + 1] के समान है, तो

      • पंक्ति [जे]:=पंक्ति [जे] * 2

      • पंक्ति हटाएं[j + 1]

  • जबकि पंक्ति का आकार <4, करें

    • पंक्ति के अंत में 0 डालें

  • बोर्ड [i] :=पंक्ति

• यदि दिशा "R" के समान है, तो

  • बोर्ड :=बोर्ड को घड़ी की विपरीत दिशा में दो बार घुमाएं

• अन्यथा जब दिशा "U" के समान हो, तब

  • बोर्ड :=बोर्ड को घड़ी की विपरीत दिशा में तीन बार घुमाएं

• अन्यथा जब दिशा "D" के समान हो, तो

  • बोर्ड :=बोर्ड को घड़ी की विपरीत दिशा में एक बार घुमाएं

• रिटर्न बोर्ड

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

उदाहरण

class Solution:
   def solve(self, board, direction):
      if direction == "R":
         board = rot_anti_clock_dir(rot_anti_clock_dir(board))
      elif direction == "U":
         board = rot_anti_clock_dir(board)
      elif direction == "D":
         board = rot_anti_clock_dir(rot_anti_clock_dir(rot_anti_clock_dir(board)))

      for i in range(4):
         row = [x for x in board[i] if x]
         for j in range(3):
            if j + 1 < len(row) and row[j] == row[j + 1]:
               row[j] *= 2
               del row[j + 1]
            while len(row) < 4:
               row += [0]
            board[i] = row

      if direction == "R":
         board = rot_anti_clock_dir(rot_anti_clock_dir(board))
      elif direction == "U":
         board = rot_anti_clock_dir(rot_anti_clock_dir(rot_anti_clock_dir(board)))
      elif direction == "D":
         board = rot_anti_clock_dir(board)
      return board


def rot_anti_clock_dir(x):
   x = [[x[i][j] for i in range(4)] for j in range(4)]
   return x[::-1]

ob = Solution()
matrix = [
[2, 0, 0, 2],
[2, 2, 2, 2],
[0, 4, 2, 2],
[2, 2, 2, 0]]
print(ob.solve(matrix, "L"))

इनपुट

matrix = [
[2, 0, 0, 2],
[2, 2, 2, 2],
[0, 4, 2, 2],
[2, 2, 2, 0]]

आउटपुट

[
[4, 0, 0, 0],
[4, 4, 0, 0],
[4, 4, 0, 0],
[4, 2, 0, 0]]