Java 可编码性:括号确定给定的括号字符串是否正确嵌套
来自Codibility的问题描述: 如果满足以下任一条件,则认为由N个字符组成的字符串S已正确嵌套: S是空的; S的形式为“(U)”或“[U]”或“{U}”,其中U是正确嵌套的字符串; S的形式为“VW”,其中V和W是正确嵌套的字符串。 例如,字符串“{[()()]}”已正确嵌套,但“([)()]”未正确嵌套 编写一个函数: 类解决方案{public int Solution(String S);} 给定由N个字符组成的字符串S,如果S正确嵌套,则返回1,否则返回0 例如,给定S=“{[()()]}”,函数应返回1,给定S=“([)()]”,函数应返回0,如上所述 假设: N是[0..200000]范围内的整数; 字符串S仅由以下字符组成:“(”、“{”、“[”、“]”、“}”和/或“)”。 复杂性: 期望最坏情况时间复杂度为O(N); 预计最坏情况下的空间复杂度为O(N)(不计算输入参数所需的存储) 我得到了87%的回报,我似乎无法解决问题。 这是我的代码:Java 可编码性:括号确定给定的括号字符串是否正确嵌套,java,stack,brackets,Java,Stack,Brackets,来自Codibility的问题描述: 如果满足以下任一条件,则认为由N个字符组成的字符串S已正确嵌套: S是空的; S的形式为“(U)”或“[U]”或“{U}”,其中U是正确嵌套的字符串; S的形式为“VW”,其中V和W是正确嵌套的字符串。 例如,字符串“{[()()]}”已正确嵌套,但“([)()]”未正确嵌套 编写一个函数: 类解决方案{public int Solution(String S);} 给定由N个字符组成的字符串S,如果S正确嵌套,则返回1,否则返回0 例如,给定S=“{[()
// you can also use imports, for example:
// import java.util.*;
import java.util.Stack;
// you can use System.out.println for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String s) {
if (s.length() % 2 != 0) {
return 0;
}
Character openingBrace = new Character('{');
Character openingBracket = new Character('[');
Character openingParen = new Character('(');
Stack<Character> openingStack = new Stack<Character>();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c == openingBrace || c == openingBracket || c == openingParen) {
openingStack.push(c);
} else {
if (i == s.length()-1 && openingStack.size() != 1) {
return 0;
}
if (openingStack.isEmpty()) {
return 0;
}
Character openingCharacter = openingStack.pop();
switch (c) {
case '}':
if (!openingCharacter.equals(openingBrace)) {
return 0;
}
break;
case ']':
if (!openingCharacter.equals(openingBracket)) {
return 0;
}
break;
case ')':
if (!openingCharacter.equals(openingParen)) {
return 0;
}
break;
default:
break;
}
}
}
return 1;
}
}
//您也可以使用导入,例如:
//导入java.util.*;
导入java.util.Stack;
//您可以使用System.out.println进行调试,例如。
//System.out.println(“这是一条调试消息”);
类解决方案{
公共整数解决方案(字符串s){
如果(s.length()%2!=0){
返回0;
}
Character openingBrace=新字符('{');
Character openingBracket=新字符('[');
Character openingParen=新字符(“(”);
堆栈openingStack=新堆栈();
对于(int i=0;i
处理此类错误的最佳方法是坐下来编写一些单元测试(JUnit是一个很好的框架),以验证您对算法工作原理的理解
在这种情况下,正如我们已经发现的那样,“负匹配”输入是)((
),您至少需要这些测试用例:
- ()(():这是您的基本测试,一旦通过,您就满足了要求,并且可以宣布至少部分胜利
:这是一般性错误,还是仅与错误处理特定字符有关}{{
:它与重复字符有关,还是在混合输入中也显示})({
:这是一种边缘情况,与在字符串开头有一个开始标记有关,还是这种行为表现得更普遍(}{)
一旦你了解了它实际上在做什么,而不是你的大脑告诉你它在做什么(你的大脑会就此向你撒谎),修复它应该相当简单。结束括号块中的第一个条件检查堆栈是否具有大小!=1。我假设这是为了检查没有剩余的开始括号,这是一个好主意。但是,如果最后一个字符不是结束括号/paren/,您将错过整个检查 例如,对于像
(
)这样的输入,这将失败
一个简单的解决方法是在循环结束后检查堆栈是否确实为空,以此来替换这种情况。因此,根据Leeor建议,这里是一个100%的解决方案
// you can also use imports, for example:
// import java.util.*;
import java.util.Stack;
// you can use System.out.println for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String s) {
if (s.length() % 2 != 0) {
return 0;
}
Character openingBrace = new Character('{');
Character openingBracket = new Character('[');
Character openingParen = new Character('(');
Stack<Character> openingStack = new Stack<Character>();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c == openingBrace || c == openingBracket || c == openingParen) {
openingStack.push(c);
} else {
if (openingStack.isEmpty()) {
return 0;
}
Character openingCharacter = openingStack.pop();
switch (c) {
case '}':
if (!openingCharacter.equals(openingBrace)) {
return 0;
}
break;
case ']':
if (!openingCharacter.equals(openingBracket)) {
return 0;
}
break;
case ')':
if (!openingCharacter.equals(openingParen)) {
return 0;
}
break;
default:
break;
}
}
}
if (!openingStack.isEmpty()) {
return 0;
}
return 1;
}
}
//您也可以使用导入,例如:
//导入java.util.*;
导入java.util.Stack;
//您可以使用System.out.println进行调试,例如。
//System.out.println(“这是一条调试消息”);
类解决方案{
公共整数解决方案(字符串s){
如果(s.length()%2!=0){
返回0;
}
Character openingBrace=新字符('{');
Character openingBracket=新字符('[');
Character openingParen=新字符(“(”);
堆栈openingStack=新堆栈();
对于(int i=0;iint solution(char *S) {
// write your code in C99
int len;
if((len=strlen(S))==0) return 1;
char stuck[len];
char open[]="([{";
char close[]=")]}";
int top=0;
for (int i=0;i<len;i++)
{
if (strchr(open,S[i])!=NULL)
{
stuck[top]=S[i];
top++;
}
else if (strchr(close,S[i])!=NULL)
{
if ((top>0)&&((strchr(open,stuck[top-1])-open)==(strchr(close,S[i])-close)))
top--;
else
return 0;
}
}
if (top==0)
return 1;
return 0;
}
function solution(S) {
S = S.split("");
var stack = [];
for (var i = 0; i < S.length; i++) {
var c = S[i];
if (c == '{' || c == '(' || c == '[')
stack.push(c);
else if (c == '}' || c == ')' || c == ']') {
var t = stack.pop() + c;
if (t != "{}" && t != "()" && t != "[]")
return 0;
}
else
return 0;
}
if (stack.length > 0)
return 0;
return 1;
}
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
class Solution {
public static final int BALANCED = 1;
public static final int UNBALANCED = 0;
public int solution(String S) {
if (S.isEmpty()) return BALANCED;
Stack<Character> stack = new Stack<>(S.length());
NestedValidatorUtil util = new NestedValidatorUtil();
for (char c: S.toCharArray()) {
if (stack.isEmpty()){
if (util.isOpener(c)) {
stack.push(c);
} else {
return UNBALANCED;
}
} else {
if(util.isOpener(c)) {
stack.push(c);
} else if(util.getOpenerForGivenCloser(c) == stack.peek()){
stack.pop();
} else {
return UNBALANCED;
}
}
}
return stack.isEmpty() ? BALANCED : UNBALANCED;
}
public static class NestedValidatorUtil {
private Map<Character, Character> language = new HashMap<Character, Character>(){{
put(')','(');
put(']','[');
put('}','{');
}};
public boolean isOpener(Character c) {
return language.values().contains(c);
}
public Character getOpenerForGivenCloser(Character closer) {
return language.get(closer);
}
}
public static class Stack<T> {
public List<T> stack;
public Stack(int capacity) {
stack = new ArrayList<>(capacity);
}
public void push(T item) {
stack.add(item);
}
public T pop() {
T item = peek();
stack.remove(stack.size() - 1);
return item;
}
public T peek() {
int position = stack.size();
T item = stack.get(position - 1);
return item;
}
public boolean isEmpty() {
return stack.isEmpty();
}
}
}
public static int solution(String S){
Stack<Character> stack = new Stack<Character>();
if(null == S){
return 0;
}else if(S.isEmpty()){
return 1;
}
for (Character C : S.toCharArray()) {
switch (C) {
case ')':
pops(stack, '(');
break;
case '}':
pops(stack, '{');
break;
case ']':
pops(stack, '[');
break;
default:
stack.push(C);
break;
}
}
return stack.isEmpty() ? 1 : 0;
}
private static void pops(Stack<Character> s, Character C){
while(!s.isEmpty() && s.peek() != C){
s.pop();
}
if(!s.isEmpty()){
s.pop();
}else{
s.push(C);
}
}
/**
* https://codility.com/demo/results/training2C7U2E-XM3/ 100%
*
* Problem facts:
* 1) A string S consisting of N characters is given
* 2) S is properly nested if:
* -S is empty;
* -S has the form "(U)" or "[U]" or "{U}" where U is a properly nested string;
* -S has the form "VW" where V and W are properly nested strings.
* 3) N is an integer within the range [0..200,000];
* 4) string S consists only of the following characters: "(", "{", "[", "]", "}" and/or ")".
* 5) expected worst-case time complexity is O(N);
* 6) expected worst-case space complexity is O(N)
*
* Solution:
* The idea is to iterate over the string and push opening brackets, then each time a closing bracket appears
* it will be matched with the last opening match stacked, if both are of the same type, then pop that char,
* otherwise return 0.
* If the string S is properly nested the remaining stack will be empty.
*
* There are three cases to analize:
* 1) The stack is empty, push the first char.
* 2) The stack is not empty, peek the last char and it is the opening bracket of current closing bracket, then
* pop the char from the stack.
* 3) The stack is not empty, peek the last char and it isn't the opening bracket of current closing bracket,
* return 0, because the string is malformed.
*
* @param S
* @return 1 if S is properly nested and 0 otherwise.
*/
public static int solution(String S) {
if(S.isEmpty()) return 1; // pay attention to corner case 1
if(S.length()==1) return 0; // and 2
Stack<Character> stack = new Stack<>();
for(int i=0; i<S.length(); i++) {
char current = S.charAt(i);
switch (current) {
case '}':
if (!stack.isEmpty() && stack.peek() == '{') {
stack.pop();
}
else return 0;
break;
case ']':
if (!stack.isEmpty() && stack.peek() == '[') {
stack.pop();
}
else return 0;
break;
case ')':
if (!stack.isEmpty() && stack.peek() == '(') {
stack.pop();
}
else return 0;
break;
default:
stack.push(current);
break;
}
}
return stack.size()==0 ? 1 : 0;
}
using System;
using System.Collections.Generic;
class Solution {
public int solution(string S) {
// Return 1 if string size is 0
if(S.Length==0) return 1;
Stack<char> brackets = new Stack<char>();
foreach(char c in S){
if(c=='['||c=='{'||c=='('){
brackets.Push(c);
}
else{
// return 0 if no opening brackets found and
// first bracket is a closing bracket
if(brackets.Count==0) return 0;
if(c==')'){
if(brackets.Peek()=='(') brackets.Pop();
else return 0;
}
if(c=='}'){
if(brackets.Peek()=='{') brackets.Pop();
else return 0;
}
if(c==']'){
if(brackets.Peek()=='[') brackets.Pop();
else return 0;
}
}
}
if(brackets.Count==0) return 1;
return 0;
}
}
class Solution {
public int solution(String S) {
char[] charArray=S.toCharArray();
//This array works as stack
char[] stack=new char[charArray.length];
//currently stack is empty
int stackSize=0;
for(int i=0;i<charArray.length;i++){
//Check start characters and add it to stack
if(charArray[i]=='{' ||charArray[i]=='(' || charArray[i]=='['){
stack[stackSize++]=charArray[i];
}else{
//This section checks for end character.
//End characters with stack being empty confirms not nested
if(stackSize==0){
result=0;
break;
}
//Pop stack
char ch=stack[--stackSize];
//check
if((charArray[i]=='}' && ch=='{') || (charArray[i]==']' && ch=='[') ||(charArray[i]==')' && ch=='(')){
continue;
}else{
//if pop character not matching, confirms non nesting
result=0;
break;
}
}
}
//if stack is not empty indicates non nested, otherwise result
return stackSize==0?result:0;
}
import java.util.*;
public static int solution(String S) {
if (S.isEmpty()) return 1;
if (S.length() % 2 == 1) return 0; // the length cannot be an odd number.
// in time complexity this decreases from O(n) to O(1).
// this Map avoid the ugly "switch case"
Map<Character, Character> map = new HashMap<Character, Character>();
map.put('}', '{');
map.put(')', '(');
map.put(']', '[');
Stack<Character> stack = new Stack<Character>();
for (Character c : S.toCharArray()) {
if (map.containsKey(c)) {
if (!stack.isEmpty() && map.get(c) == stack.peek()) {
stack.pop();
} else {
return 0;
}
} else {
stack.push(c);
}
}
return stack.isEmpty() ? 1 : 0;
}
public int solution(String S) {
Stack<Character> stack = new Stack<>();
for(int i=0; i<S.length(); i++) {
char c = S.charAt(i);
if (c == '[' || c == '{' || c == '(' || c == 'V') {
stack.push(c);
} else if (c == ']' || c == '}' || c == ')' || c == 'W') {
if (checkBracket(stack, c)) {
stack.pop();
} else {
return 0;
}
} else {
return 0;
}
}
if (stack.empty()) {
return 1;
}
return 0;
}
private boolean checkBracket(Stack<Character> stack, char bracket) {
if (stack.empty()) return false;
char lastStackBracket = stack.peek();
if (lastStackBracket == '{' && bracket == '}') {
return true;
} else if (lastStackBracket == '[' && bracket == ']') {
return true;
} else if (lastStackBracket == '(' && bracket == ')') {
return true;
} else if (lastStackBracket == 'V' && bracket == 'W') {
return true;
}
return false;
}
import java.util.*;
function solution(S) {
if (0 === S.length) {
return 1
}
let stack = []
for (let i = 0; i < S.length; i++) {
if ('(' === S[i] || '{' === S[i] || '[' === S[i]) {
stack.push(S[i])
} else {
let couple = [stack.pop(), S[i]].join('')
if ('()' !== couple && '{}' !== couple && '[]' !== couple) {
return 0
}
}
}
if (stack.length) {
return 0
}
return 1
}
public func Brackets(_ S : inout String) -> Int {
var Stack = [Character]()
let matching : [Character:Character] = ["(":")", "[":"]", "{":"}"]
for s in S {
let char = S.removeFirst()
if "({[".contains(char) {
print(char)
Stack.append(char)
}
if( "]})".contains(char)) {
print(char)
let bracket = Stack.removeLast()
if matching[bracket] != char {
return 0
}
}
}
return 1
}
var S1 = "{[()()]}"
var S2 = "([)()]"
print("Brackets: ", Brackets(&S1))
print("Brackets: ", Brackets(&S2))
public int solution(String S) {
Deque<Character> stack = new ArrayDeque<Character>();
for(int i = 0; i < S.length(); i++) {
char c = S.charAt(i);
switch (c) {
case ')':
if (stack.isEmpty() || stack.pop() != '(')
return 0;
break;
case ']':
if (stack.isEmpty() || stack.pop() != '[')
return 0;
break;
case '}':
if(stack.isEmpty() || stack.pop() != '{')
return 0;
break;
default:
stack.push(c);
break;
}
}
return stack.isEmpty() ? 1 : 0;
}
int solution(string S) {
int N = S.size();
if(N == 0) return 1;//empty string is properly nested
if(S[0] == ')' || S[0] == ']' || S[0] == '}' ) return 0;// a properly nested string cannot beging with those chars
if(S[N-1] == '(' || S[N-1] == '[' || S[N-1] == '{' ) return 0; // cannot end with those chars
int paren_open = 0;
int brac_open = 0;
int curl_open = 0;
for(int i =0 ; i < N;++i){
if(S[i] == ')' && (paren_open == 0 || S[i-1] == '[' || S[i-1] == '{')) return 0; //expected opening but got closing
if(S[i] == ']' && (brac_open == 0 || S[i-1] == '(' || S[i-1] == '{')) return 0; //same here
if(S[i] == '}' && (curl_open == 0 || S[i-1] == '[' || S[i-1] == '(')) return 0; //same here
if(S[i] == '(') paren_open++;
else if(S[i] == ')') paren_open--;
else if(S[i] == '[') brac_open++;
else if(S[i] == ']') brac_open--;
else if(S[i] == '{') curl_open++;
else if(S[i] == '}') curl_open--;
}
if(paren_open == 0 && brac_open == 0 && curl_open ==0)
return 1;
return 0; }
def solution(S):
# write your code in Python 3.6
arr = []
if len(S) < 1:
return 1
if not isinstance(S, str):
return 0
for i in range(0, len(S)):
# print(S[i])
if startSym(S[i]):
arr.append(value(S[i]))
# print(arr)
elif endSym(S[i]):
if len(arr) > 0 and value(S[i]) == arr[len(arr) - 1]:
# print(S[i])
# print(arr)
del arr[len(arr) - 1]
else:
return 0
else:
return 0
if len(arr) == 0:
return 1
else:
return 0
def startSym(x):
if x == '{' or x == '[' or x == '(':
return True
else:
return False
def endSym(x):
if x == '}' or x == ']' or x == ')':
return True
else:
return False
def value(x):
if x == '{' or x == '}':
return 1
if x == '[' or x == ']':
return 2
if x == '(' or x == ')':
return 3
def solution(S):
matches, stack = dict(['()', '[]', '{}']), []
for i in S:
if i in matches.values():
if stack and matches[stack[-1]] == i:
stack.pop()
else:
return 0
else:
stack.append(i)
return int(not stack)
def solution(s)
s.split('').inject([]) do |stack, el|
next stack.push(el) if ['[', '{', '('].include?(el)
current = stack.pop
next stack if (current == '{' && el == '}') ||
(current == '(' && el == ')') ||
(current == '[' && el == ']')
return 0
end.empty? ? 1 : 0
end
4 push 4 pop
{[()()]}
push {
push [
push (
pop )
push (
pop )
pop ]
pop }
gets empty
2 push 1 pop
([)()]
(
[
) - not matching with [ so not balanced
def solution(S):
stack = []
for bracket in S:
# open bracket found push in to stack, used array as stack append item at top
if bracket == "{" or bracket == "[" or bracket == "(":
stack.append(bracket)
# any closing bracket found and stack is not empty remote item from stack top
elif bracket == "}" and stack:
pop_item = stack.pop()
# check popped item, if it is not similar( ie. opposite or open) as bracket then this S can not be balanced
if pop_item != "{":
return 0
elif bracket == "]" and stack:
pop_item = stack.pop()
if pop_item != "[":
return 0
elif bracket == ")" and stack:
pop_item = stack.pop()
if pop_item != "(":
return 0
# at any point if neither open nor close operation can be performed, stack is not balanced
else:
return 0
print(stack)
# if stack is empty stack, it is balanced ie. all push and pop operation on S is successful¬.
if not stack:
return 1
# S is not balanced
return 0
if __name__ == '__main__':
# result = solution("{[()()]}")
result = solution("([)()]")
print("")
print("Solution " + str(result))
['{']
['{', '[']
['{', '[', '(']
['{', '[']
['{', '[', '(']
['{', '[']
['{']
[]
Solution 1
['(']
['(', '[']
Solution 0
using System;
using System.Collections.Generic;
using System.Linq;
class Solution {
private Dictionary<char,char> closing = new Dictionary<char,char>{{'}','{'},{')','('},{']','['}};
public int solution(string S) {
var stack = new Stack<char>();
foreach(var c in S)
{
if(!closing.Keys.Contains(c))
stack.Push(c);
else if(!stack.Any() || closing[c] != stack.Pop() )
return 0;
}
return !stack.Any() ? 1 : 0;
}
}
def solution(S):
if len(S) == 0:
return 1
opening = ["(", "{", "["]
closing = [")", "}", "]"]
ls_my_o = []
for s in S:
if s in opening:
ls_my_o.append(s)
elif s in closing:
if len(ls_my_o) < 1:
return 0
ele = ls_my_o.pop()
if opening.index(ele) != closing.index(s):
return 0
if len(ls_my_o) == 0:
return 1
return 0
# Brackets
def solution(S):
if not S:
return 1
stack = []
brackets = {"(": ")", "{": "}", "[": "]"}
for elem in S:
if elem in brackets:
stack.append(elem)
if elem in brackets.values():
if stack:
if elem == brackets[stack.pop()]:
continue
else:
return 0
else:
return 0
return 0 if stack else 1
public func solution(_ S : inout String) -> Int {
var stack: [Character] = []
let pairFor: [Character: Character] = ["(":")",
"{":"}",
"[":"]"]
let opening: Set<Character> = ["(","{","["]
let closing: Set<Character> = [")","}","]"]
for char in S {
if opening.contains(char) {
stack.append(char)
} else if closing.contains(char) {
guard stack.isEmpty == false else {
return 0
}
let bracket = stack.removeLast()
if pairFor[bracket] != char {
return 0
}
}
}
return stack.isEmpty ? 1 : 0
$sa = str_split($S);
if(strlen($S) == 0){
return 1;
}
$count = count($sa);
$res =1;
$opening = ['{'=>'}','('=>')','['=>']'];
$array =['{'=>'}','}'=>'{',')'=>'(','('=>')','['=>']',']'=>'['] ;
$stack = [];
for($i =0;$i<$count;$i++){
if(isset($opening[$sa[$i]])){
array_push($stack,$sa[$i]);
}else{
if(count($stack) == 0){
return 0;
}
$v = array_pop($stack);
if($array[$sa[$i]] !== $v){
return 0;
}
}
}
if (sizeof($stack) != 0) return 0;
return 1;
#include <stack>
int solution(string &S) {
// write your code in C++14 (g++ 6.2.0)
auto N = S.size();
stack<char> ST;
for(decltype(N) i{0}; i < N; i++) {
if ((S[i] == '{') || (S[i] == '[') || (S[i] == '(')) {
ST.push(S[i]);
}
else {
if (ST.empty()) {
return false;
}
char top = ST.top();
ST.pop();
if ((S[i] == ')') && (top != '(')) {
return false;
}
if ((S[i] == ']') && (top != '[')) {
return false;
}
if ((S[i] == '}') && (top != '{')) {
return false;
}
}
}
return ST.empty();
}
class Solution {
public int solution(String S) {
// write your code in Java SE 8
Stack<Character> myStack = new Stack<Character>();
for(Character singleChar : S.toCharArray()){
if((singleChar.equals('(')) || (singleChar.equals('{')) || (singleChar.equals('['))){
myStack.push(singleChar);
}
else{
if(myStack.size() == 0){
System.out.println("Stack size");
return 0;
}
if(singleChar.equals(')')){
if(myStack.peek().equals('('))
myStack.pop();
else
return 0;
}
if(singleChar.equals('}')){
if(myStack.peek().equals('{'))
myStack.pop();
else
return 0;
}
if(singleChar.equals(']')){
if(myStack.peek().equals('['))
myStack.pop();
else
return 0;
}
}
}
if(myStack.size()==0)
return 1;
else
return 0;
}
import java.util.Stack;
public class Brackets {
public int solution(String S) {
Stack<Character> stack = new Stack<>();
for (int i = 0; i < S.length(); i++) {
if (!process(stack, S.charAt(i))) {
return 0;
}
}
return stack.empty() ? 1 : 0;
}
private boolean process(Stack<Character> stack, char ch) {
Character opener = getOpener(ch);
if (opener == null) {
stack.push(ch);
} else {
if (stack.empty()) {
return false;
}
char top = stack.peek();
if (opener.equals(top)) {
stack.pop();
} else {
return false;
}
}
return true;
}
private Character getOpener(char ch) {
switch (ch) {
case ')':
return '(';
case '}':
return '{';
case ']':
return '[';
default:
return null;
}
}
}
class Solution {
public int solution(String S) {
Stack<Character> myStack = new Stack<>();
char[] chars = S.toCharArray();
for (int i = 0; i < chars.length; i++) {
char coming = chars[i];
switch(coming){
case '(': case '{': case '[':
myStack.push(coming);
break;
case ')': case '}': case ']':
if(myStack.isEmpty())
return 0;
char popped = myStack.pop();
if(!isValidPair(coming, popped))
return 0;
}
}
if(!myStack.isEmpty())
return 0;
return 1;
}
private boolean isValidPair(char c, char s) {
return ((c == ')' && s == '(') || (c == '}' && s == '{') || (c == ']' && s == '['));
}
}