एक स्ट्रिंग जावास्क्रिप्ट

Question

में लापता ब्रेसिज़ ढूंढें मैंने "(" और ")" के लिए कंस्ट्रैसिस की जांच करने के लिए तर्क लिखा है लेकिन ब्रांड्स को मिश्रित होने पर कोई समस्या दिखाई देती है। ऐसा इसलिए है क्योंकि मैं सिर्फ कुल कोष्ठक गणना की तुलना कर रहा हूं।

यह मैं क्या लिखा है

function checkParanthesis(str){ 
 
    var depth=0; 
 
    for(var i in str){ 
 
    if(str[i] == "(" || str[i] == "{" || str[i] == "[") 
 
     depth++; 
 
    else if(str[i] == ")" || str[i] == "}" || str[i] == "]") 
 
     depth--; 
 
    } 
 
    
 
    if(depth !==0) return false; 
 
    
 
    return true; 
 
} 
 

 
console.log(checkParanthesis("() test"));

प्रश्न है:

लेकिन मैं कैसे कई कोष्टक तत्वों के लिए जाँच कर सकते हैं?() {} []

उदाहरण के लिए,

इनपुट:

"[(]) abcd" // should return false 
"[{()}] test" // should return true 

लौट चाहिए झूठी (नहीं सच)

Answer 1

ढेर ट्रैक रखने के लिए के रूप में एक सरणी का उपयोग करें अनसुलझे उद्घाटन ब्रेसिज़:

function checkParanthesis(str){ 
    var stack=[]; 
    for(var i=0; i<str.length; i++){ 
    if(str[i] == "(" || str[i] == "{" || str[i] == "[") 
     stack.push(str[i]); 
    else if(str[i] == ")") { 
     if(stack.pop() != "(") { return false; } 
    } 
    else if(str[i] == "}") { 
     if(stack.pop() != "{") { return false; } 
    } 
    else if(str[i] == "]") { 
     if(stack.pop() != "[") { return false; } 
    } 
    } 

    return !stack.length; 
} 

आप शायद इस अधिक पठनीय होने के लिए साफ कर सकते हैं, लेकिन मूल रूप:

• हर बार जब आप एक उद्घाटन ब्रेस मिल जाए, ढेर में जोड़ें।
• हर बार जब आप एक बंद ब्रेस देखते हैं, तो ढेर को पॉप करें और देखें कि स्टैक का शीर्ष एक मिलान करने वाला उद्घाटन ब्रेस है या नहीं।
  • यदि ऐसा नहीं है, तो आपके पास कोई मेल नहीं है, तो आप तुरंत false वापस कर सकते हैं।
• आप समाप्त करने के लिए यह करते हैं, तो आप, किसी भी त्रुटि का पता नहीं था लौटने true अगर ढेर खाली है (अर्थात, stack.length0 है)।

(ध्यान दें, क्योंकि यह String.prototype पर गुण से अधिक पुनरावृति जाएगा मैं भी अपने i in str पाश बदल दिया है।)

एक सफाई तुम कर सकते हो (लेकिन मुझे यकीन नहीं कर रहा हूँ अगर यह कोड अधिक पठनीय है या नहीं करता है) ब्रेस जोड़ी को ऑब्जेक्ट में रखना होगा, बंद चरित्र के साथ कुंजी और संबंधित उद्घाटन चरित्र के रूप में मूल्य के रूप में। तो फिर, अगर वर्तमान चरित्र एक महत्वपूर्ण in वस्तु के रूप में मौजूद है देखते हैं, और यदि हां, तो ढेर पॉप और अगर उस कुंजी मैचों के लिए मूल्य देखें: एक काउंटर

function checkParanthesis(str){ 
    var stack=[]; 
    var brace_pairings = { ")":"(", "}":"{", "]":"[" }; 
    for(var i=0; i<str.length; i++){ 
    if(str[i] == "(" || str[i] == "{" || str[i] == "[") { 
     stack.push(str[i]); 
    } else if(str[i] in brace_pairings) { 
     if(stack.pop() != brace_pairings[str[i]]) { return false; } 
    } 
    } 

    return !stack.length; 
} 

Answer 2

के बजाय, आप एक ढेर इस्तेमाल कर सकते हैं, जब एक उद्घाटन ब्रैकेट देखा जाता है तो स्टैक पर टोकन को दबाकर, और पर स्टैक से पॉपिंग सही समापन ब्रैकेट देखा जाता है। यदि एक बंद ब्रैकेट का सामना किया जाता है जब स्टैक के शीर्ष पर एक अलग प्रकार का ब्रैकेट होता है, या जब स्टैक खाली होता है, तो स्ट्रिंग असंतुलन होती है।

कुछ इस तरह (पॉलिश और परीक्षण नहीं):

function checkParanthesis(str){ 
var stack = []; 
var open; 
for(var i in str){ 
    if(str[i] == "(" || str[i] == "{" || str[i] == "[") { 
    stack.push(str[i]); 
    } 
    else if(str[i] == ")" || str[i] == "}" || str[i] == "]") { 
    if (stack.length == 0) { 
     return false; 
    } 
    open = stack.pop(); 
    if (
     (open == '(' && str[i] != ')') 
     || (open == '[' && str[i] != ']') 
     || (open == '{' && str[i] != '}') 
    ) { 
     return false; 
    } 
    } 
} 

if (stack.length > 0) { 
    return false; 
} 

return true; 
} 

Answer 3

एक regex का प्रयोग करें एक match() सरणी में सभी ब्रेसिज़ पाने के लिए ... तो परीक्षण प्रत्येक सेट

function checkParanthesis(str) { 
 
    //hashmap to compare open/close braces 
 
    var closers = {'[': ']','(': ')','{': '}'}; 
 
    // create braces array 
 
    var parStack = str.match(/\(|\{|\[|\)|\}|\]/g) || []; 
 

 
    if (parStack.length % 2 !== 0) {//must have even number 
 
    return false; 
 
    } else { 
 
    while (parStack.length) { 
 
     // check each end of array against each other. 
 
     if (closers[parStack.shift()] !== parStack.pop()) { 
 
     //mismatch , we're done 
 
     return false; 
 
     } 
 
    } 
 
    return true; 
 
    } 
 

 
} 
 
console.log('no braces ', checkParanthesis("test")); 
 
console.log('matched ', checkParanthesis("() test")); 
 
console.log('mis matched ',checkParanthesis("[(]) abcd")); // should return false 
 
console.log('matched ',checkParanthesis("[{()}] test"));

सरणी के प्रत्येक छोर को दूर

Answer 4

सरणी/ढेर/काउंटर दृष्टिकोण स्ट्रिंग बाएं से दाएं पढ़ता है। एक और दृष्टिकोण अंदरूनी से काम करना है।

function checkParanthesis(str){ 
    while (str.indexOf('()')>=0 || str.indexOf('[]')>=0 || str.indexOf('{}')>=0) { 
    str = str.replace('()','').replace('[]','').replace('{}',''); 
    } 
    return str.length===0; 
} 

आप वैश्विक प्रतिस्थापन और लूप कम समय के लिए प्रतिस्थापन भाग के लिए नियमित अभिव्यक्तियों का उपयोग कर सकते हैं। नकारात्मकता यह है कि आपको दृष्टि में सबकुछ से बचने की आवश्यकता होगी: str.replace(/\(\)/g,'') et.c.