पायथन में वॉकिंग रोबोट सिमुलेशन

मान लीजिए एक अनंत ग्रिड पर एक रोबोट है जो बिंदु (0, 0) से शुरू होता है। यह उत्तर दिशा की ओर मुंह किए होता है। अब रोबोट तीन संभावित प्रकार के कमांड प्राप्त कर सकता है -

1. -2 बाएं 90 डिग्री मोड़ने के लिए
2. -1 दाएं 90 डिग्री मोड़ने के लिए
3. 1 से 9 तक का कोई भी मान x यूनिट आगे बढ़ने के लिए
4. कुछ ग्रिड वर्ग बाधाएं हैं।

हमारे पास बाधा नामक एक और सरणी है, यह दर्शाता है कि i-वीं बाधा ग्रिड बिंदु (obstacles[i][0], obstacles[i][1]) पर है। यदि रोबोट उन पर चलना चाहता है, तो रोबोट पिछले ग्रिड वर्ग पर ही रहता है।

हमें उस अधिकतम यूक्लिडियन दूरी का वर्ग ढूंढना है जो रोबोट मूल बिंदु से होगा।

तो, यदि इनपुट commands = [4,-1,4,-2,4], obstacles = [[2,4]] जैसा है, तो आउटपुट 65 होगा, क्योंकि रोबोट (1, 4) पर अटक जाएगा बाएं मुड़ने और (1, 8) जाने से पहले।

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

• position_offset := [(0, 1), (1, 0), (0, -1), (-1, 0)]
• x, y, direction, max_distance को 0 से आरंभ करें
• commands में प्रत्येक कमांड के लिए, करें
  • यदि कमांड, -2 के समान है, तो
    • direction := (direction - 1) mod 4
  • अन्यथा जब कमांड, -1 के समान है, तो
    • direction := (direction + 1) mod 4
  • अन्यथा,
    • (x_off, y_off) := position_offset[direction]
  • जब कमांड शून्येतर है, करें
    • यदि (x + x_off, y + y_off) बाधाओं में नहीं है, तो
      • x := x + x_off
      • y := y + y_off
    • कमांड := कमांड - 1
  • max_distance = max_distance, x^2 + y^2 का अधिकतम
• max_distance लौटाएं

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

उदाहरण

class Solution:
    def robotSim(self, commands, obstacles):
        position_offset = [(0, 1), (1, 0), (0, -1), (-1, 0)]
        obstacles = set(map(tuple, obstacles))
        x, y, direction, max_distance = 0, 0, 0, 0
        for command in commands:
            if command == -2:
                direction = (direction - 1) % 4
            elif command == -1:
                direction = (direction + 1) % 4
            else:
                x_off, y_off = position_offset[direction]
                while command:
                    if (x + x_off, y + y_off) not in obstacles:
                        x += x_off
                        y += y_off
                    command -= 1
                max_distance = max(max_distance, x**2 + y**2)
        return max_distance

ob = Solution()
print(ob.robotSim([4, -1, 4, -2, 4], [[2, 4]]))

इनपुट

[4,-1,4,-2,4],[[2,4]]

आउटपुट

65