C++ में रोबोट बाउंडेड इन सर्कल (Robot Bounded In Circle)

मान लीजिए हमारे पास एक अनंत तल है, एक रोबोट प्रारंभ में स्थिति (0, 0) पर खड़ा है और उत्तर दिशा की ओर मुख किए हुए है। रोबोट को तीन निर्देशों में से एक प्राप्त हो सकता है:

• G - सीधे 1 इकाई आगे बढ़े;

• L - बाएं 90 डिग्री मुड़े;

• R - दाएं 90 डिग्री मुड़े।

रोबोट दिए गए क्रम में निर्देशों का पालन करता है, और निर्देश अनंत काल तक दोहराए जाते हैं। हमें जांचना है कि क्या तल में कोई वृत्त मौजूद है जिससे रोबोट कभी बाहर न निकले।

उदाहरण के लिए, यदि इनपुट "GGLLGG" है, तो उत्तर true होगा। (0,0) से (0,2) तक जाकर यह अनंत लूप में चलेगा, इसलिए यह एक बंद पथ है।

समाधान दृष्टिकोण

1. दिशा ऐरे dir := [[0,1], [1,0], [0,-1], [-1,0]] बनाएं

2. एक जोड़ी temp (0, 0) और k := 0 से प्रारंभ करें

3. प्रत्येक निर्देश के लिए: G होने पर temp को अपडेट करें, L होने पर k = (k+1)%4, R होने पर k = (k-1+4)%4

4. यदि temp (0,0) नहीं है और k > 0, तो true लौटाएं, अन्यथा false

C++ कार्यान्वयन

#include <bits/stdc++.h> 
using namespace std; 

int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; 

class Solution { 
public: 
    bool isRobotBounded(string s) { 
        pair<int, int> temp({0,0}); 
        int k = 0; 
        for(int i = 0; i < s.size(); i++){ 
            if(s[i] == 'G'){ 
                temp.first += dir[k][0]; 
                temp.second += dir[k][1]; 
            }else if(s[i] == 'L'){ 
                k = (k + 1) % 4; 
            }else{ 
                k = ((k - 1) + 4) % 4; 
            } 
        } 
        return temp.first == 0 && temp.second == 0 || k > 0; 
    } 
}; 

int main(){ 
    Solution ob; 
    cout << (ob.isRobotBounded("GGLLGG")); 
    return 0; 
}

इनपुट

"GGLLGG"

आउटपुट

1