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

C++ में न्यूनतम ब्रैकेट जोड़

मान लीजिए कि हमारे पास एक स्ट्रिंग है जिसमें केवल '(' और ')' है, हमें स्ट्रिंग को संतुलित करने के लिए सम्मिलित किए जा सकने वाले कोष्ठकों की न्यूनतम संख्या ज्ञात करनी होगी।

इसलिए, यदि इनपुट "(())) (" जैसा है, तो आउटपुट 2 होगा "(()))(", इसे संतुलित किया जा सकता है जैसे"((()))()"।

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

  • :=0, सीएनटी:=0

  • इनिशियलाइज़ i:=0 के लिए, जब i <साइज़ ऑफ़ s, अपडेट (i से 1 तक बढ़ाएँ), करें -

    • अगर s[i] '(' के समान है, तो -

      • (1 से बढ़ाएँ)

    • अन्यथा

      • यदि o शून्येतर है, तो -

        • (o 1 से घटाएं)

      • अन्यथा

        • (cnt 1 से बढ़ाएँ)

  • वापसी सीएनटी + ओ

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

उदाहरण

#include <bits/stdc++.h>
using namespace std;
class Solution {
   public:
   int solve(string s) {
      int o = 0;
      int cnt = 0;
      for(int i = 0; i < s.size(); i++){
         if(s[i] == '('){
            o++;
         } else {
            if(o)
               o--;
            else
               cnt++;
         }
      }
      return cnt + o;
   }
};
int main(){
   Solution ob;
   cout << (ob.solve("(()))("));
}

इनपुट

Input:
"(()))("

आउटपुट

2

  1. C++ में बाइनरी ट्री की न्यूनतम गहराई

    मान लीजिए हमारे पास एक बाइनरी ट्री है; हमें उस वृक्ष की न्यूनतम गहराई ज्ञात करनी है। जैसा कि हम जानते हैं कि न्यूनतम गहराई रूट नोड से निकटतम लीफ नोड तक सबसे छोटे पथ के साथ नोड्स की संख्या है। तो, अगर इनपुट पसंद है तो आउटपुट 2 . होगा इसे हल करने के लिए, हम इन चरणों का पालन करेंगे - ट्री नोड्स

  1. C++ में न्यूनतम नाइट मूव्स

    मान लीजिए कि हमारे पास एक अनंत शतरंज की बिसात है जिसमें -infinity से +infinity तक के निर्देशांक हैं, और हमारे पास वर्ग [0, 0] पर एक नाइट है। एक शूरवीर के पास 8 संभावित चालें हैं, जैसा कि नीचे दिखाया गया है। प्रत्येक चाल एक कार्डिनल दिशा में दो वर्ग है, फिर एक वर्ग एक ओर्थोगोनल दिशा में है। हमें न

  1. न्यूनतम x ऐसे खोजें कि (x% k) * (x / k) ==n C++ . में

    दो धनात्मक पूर्णांक n और k दिए गए हैं, और हमें धनात्मक पूर्णांक x ज्ञात करना है, जैसे कि (x% k)*(x / k) n के समान हो। तो अगर n और k क्रमशः 4 और 6 हैं, तो आउटपुट 10 होगा। तो (10% 6) * (10 / 6) =4. जैसा कि हम जानते हैं कि x% k का मान रेंज [1 से k - 1] (0 शामिल नहीं है) में होगा। * के) / (एक्स% के) +