पायथन में दिए गए दिशा में एक बार स्लाइड करने के बाद अगला बोर्ड पोजिशन ढूंढने का प्रोग्राम

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

एल्गोरिदम

• अगर दिशा "R" के समान है, तो बोर्ड को एंटी-क्लॉकवाइज दो बार घुमाएं
• अन्यथा जब दिशा "U" के समान है, तो बोर्ड को एंटी-क्लॉकवाइज एक बार घुमाएं
• अन्यथा जब दिशा "D" के समान है, तो बोर्ड को एंटी-क्लॉकवाइज तीन बार घुमाएं
• i को 0 से 3 तक रेंज में, करें
  • row := board[i] पर सभी नॉन-जीरो एलिमेंट्स की सूची
  • j को 0 से 2 तक रेंज में, करें
    • अगर j+1 < row का आकार और row[j] row[j+1] के समान है, तो
      • row[j] := row[j] * 2
      • row[j+1] हटाएं
  • जब तक row का आकार < 4, करें
    • row के अंत में 0 डालें
  • board[i] := row
• मूल दिशा के आधार पर बोर्ड को वापस घुमाएं
• board लौटाएं

इम्प्लीमेंटेशन

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]
]