C++ में स्ट्रिंग में सभी स्थितियों तक सिग्नल पहुंचने का समय ढूंढना

परिचय

इस ट्यूटोरियल में हम एक ऐसा प्रोग्राम लिखेंगे जो स्ट्रिंग में सभी स्थितियों तक सिग्नल पहुंचने में लगने वाले समय की गणना करता है। आइए एक उदाहरण से समझते हैं।

हमारे पास एक स्ट्रिंग होगी जिसमें केवल s और p कैरेक्टर होंगे। s एक सिग्नल है और p स्ट्रिंग में एक स्थिति (position) है। एक सिग्नल s से शुरू होता है और बाएं और दाएं दोनों दिशाओं में यात्रा करता है। हम मान रहे हैं कि स्ट्रिंग में अगली स्थिति तक यात्रा करने में एक इकाई समय लगता है। हमारा कार्य सभी स्थितियों को सिग्नल में बदलने के लिए आवश्यक समय की गणना करना है।

उदाहरण

इनपुट - pppppspss

आउटपुट - 5

इनपुट - pspspsps

आउटपुट - 1

इनपुट - ssssss

आउटपुट - 0

समस्या समाधान के चरण

1. एक स्ट्रिंग और समय (0) इनिशियलाइज़ करें।
2. स्ट्रिंग पर पुनरावृत्ति करें।
   • लगातार p कैरेक्टर्स गिनें और काउंट को एक वेरिएबल में स्टोर करें।
   • यदि वर्तमान कैरेक्टर s है और p काउंट पिछले समय से अधिक है तो जांचें कि बाईं ओर s मौजूद है या नहीं।
   • यदि s दोनों तरफ मौजूद है, तो काउंट को दो हिस्सों में बांटें क्योंकि s दोनों दिशाओं में यात्रा कर सकता है।
   • p की गिनती रीसेट करें।

उदाहरण कोड

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

int timeToConvertToSignalString(string sample_string, int string_len) {
    int p_count = 0, time = 0;
    for (int i = 0; i <= string_len; i++) {
        if (sample_string[i] == 'p') {
            p_count++;
        } else {
            if (p_count > time) {
                bool is_present_left_side = false;
                if (((i - p_count) > 0) && (sample_string[i - p_count - 1] == 's')) {
                    is_present_left_side = 1;
                }
                if (is_present_left_side) {
                    p_count = ceil((double)p_count / 2);
                }
                time = max(time, p_count);
            }
            p_count = 0;
        }
    }
    return time;
}

int main() {
    string sample_string = "pppppspss";
    int n = sample_string.size();
    cout << timeToConvertToSignalString(sample_string, n) << endl;
    return 0;
}

आउटपुट

5

व्याख्या

"pppppspss" के लिए: पहले 5 p's, फिर s, फिर p, फिर ss। पहले 5 p's को कवर करने के लिए बाएं s को 5 यूनिट समय लगता है (कोई बायां s नहीं)। मध्य p के दोनों तरफ s हैं, इसलिए 1/2 = 0.5 → 1 यूनिट। अधिकतम = 5।

निष्कर्ष

यह एल्गोरिदम सिग्नल प्रोपेगेशन का अनुकरण करता है। विभिन्न टेस्ट केस के साथ प्रोग्राम चलाकर जांचें। यदि आपके कोई प्रश्न हैं, तो कमेंट सेक्शन में पूछें।