Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> C++

C++ में O(1) स्थान और O(N^2) समय जटिलता के साथ अभिव्यक्ति में संतुलित पैरेंथेसिस की जांच

अवधारणा

दिए गए स्ट्रिंग str जिसमें वर्ण '(', ')', '{', '}', '[' और ']' हैं, यह पता लगाना है कि ब्रैकेट संतुलित हैं या नहीं।

ब्रैकेट संतुलित माने जाते हैं यदि:

  • खुले ब्रैकेट को उसी प्रकार के ब्रैकेट से बंद किया जाना चाहिए।
  • खुले ब्रैकेट को सही क्रम में बंद किया जाना चाहिए।

उदाहरण

इनपुट - str = "(()){}"

आउटपुट - Yes

इनपुट - str = "))(([]["

आउटपुट - No

विधि

  • दो चर a और b निर्दिष्ट करें ताकि तुलना किए जाने वाले दो ब्रैकेट को ट्रैक किया जा सके।
  • एक काउंट बनाए रखें जिसका मान खुले ब्रैकेट मिलने पर बढ़ता है और बंद ब्रैकेट मिलने पर घटता है।
  • खुले ब्रैकेट मिलने पर b = a, a = a + 1 और count = count + 1 निर्दिष्ट करें।
  • जब बंद ब्रैकेट मिलते हैं तो काउंट घटाएं और i और j पर ब्रैकेट की तुलना करें:
    • यदि a और b पर ब्रैकेट मेल खाते हैं, तो स्ट्रिंग में a-वें और b-वें स्थान पर '#' डालें। a को बढ़ाएं और b को घटाएं जब तक गैर-'#' मान न मिल जाए या b >= 0।
    • यदि a और b पर ब्रैकेट मेल नहीं खाते तो गलत लौटाएं।
  • यदि count != 0 तो गलत लौटाएं।

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

// C++ implementation of the approach
#include <iostream>
using namespace std;

bool helperFunc(int& count1, string& s1, int& i1, int& j1, char tocom1){
    count1--;
    if (j1 > -1 && s1[j1] == tocom1) {
        s1[i1] = '#';
        s1[j1] = '#';
        while (j1 >= 0 && s1[j1] == '#')
            j1--;
        i1++;
        return 1;
    }
    else
        return 0;
}

bool isValid(string s1){
    if (s1.length() == 0)
        return true;
    else {
        int i1 = 0;
        int count1 = 0;
        int j1 = -1;
        bool result1;
        while (i1 < s1.length()) {
            switch (s1[i1]) {
                case '}':
                    result1 = helperFunc(count1, s1, i1, j1, '{');
                    if (result1 == 0) {
                        return false;
                    }
                    break;
                case ')':
                    result1 = helperFunc(count1, s1, i1, j1, '(');
                    if (result1 == 0) {
                        return false;
                    }
                    break;
                case ']':
                    result1 = helperFunc(count1, s1, i1, j1, '[');
                    if (result1 == 0) {
                        return false;
                    }
                    break;
                default:
                    j1 = i1;
                    i1++;
                    count1++;
            }
        }
        if (count1 != 0)
            return false;
        return true;
    }
}

int main(){
    string str1 = "[[]][]()";
    if (isValid(str1))
        cout << "Yes";
    else
        cout << "No";
    return 0;
}

आउटपुट

Yes
  1. C++ में प्रायोरिटी शेड्यूलिंग प्रोग्राम C++ में प्रायोरिटी शेड्यूलिंग प्रोग्राम

    हमें n प्रक्रियाएं P1, P2, P3, ..., Pn दी गई हैं, जिनके साथ उनके बर्स्ट टाइम (burst time) और प्रायोरिटी (priority) जुड़े हुए हैं। कार्य प्रायोरिटी CPU शेड्यूलिंग एल्गोरिदम का उपयोग करके औसत वेटिंग टाइम, औसत टर्नअराउंड टाइम और प्रक्रिया निष्पादन का क्रम ढूंढना है। वेटिंग टाइम और टर्नअराउंड टाइम क्या

  1. - पायथन में अभिव्यक्ति में संतुलित पैरेंथेसिस की जांच O(1) स्पेस और O(N²) समय जटिलता के साथ

    मान लीजिए हमारे पास एक स्ट्रिंग str है जिसमें ये ब्रैकेट हैं: (, ), {, }, [ और ]। हमें जांचना है कि ब्रैकेट संतुलित हैं या नहीं। हम कह सकते हैं कि ब्रैकेट संतुलित हैं जब: ओपनिंग और क्लोजिंग ब्रैकेट का प्रकार समान हो। ब्रैकेट सही क्रम में बंद हों। इसलिए, यदि इनपुट {([])} है, तो आउटपुट True होगा। स

  1. - पायथन में बैलेंस्ड पैरेंथेसेस की जांच

    कई बार हमें यह पता लगाने की आवश्यकता होती है कि कोई एक्सप्रेशन इसमें मौजूद ब्रैकेट्स के संबंध में बैलेंस्ड है या नहीं। बैलेंस्ड से हमारा मतलब है कि प्रत्येक लेफ्ट ब्रैकेट के लिए एक संगत राइट ब्रैकेट है और ब्रैकेट्स का क्रम उचित रूप से व्यवस्थित है। प्रोग्राम या गणितीय एक्सप्रेशन लिखने में इसका महत्