CareerCup

Use Stack.
Push into the stack until you a get a closing brace.
On getting a closing brace, pop out an element from the stack.
If (you got anything but a brace continue popping until you get a brace)
check the brace is a matching one else return "wrong string"
continue with the string
else(if you got a brace on first pop) it would be an extra brace
return "wrong string"

private static boolean checkBracesSequence(String string) {
		Stack st = new Stack();
		
		for(char c: string.toCharArray()) {
			if( c != ')' && c != '}' && c!= ']') {
				st.push(c);
			} 
			else {
				int count =0;
				while(!st.isEmpty()) {
					char t = st.pop().toString().charAt(0);
					if(t =='(' || t == '{' || t == '[') {
						if(count == 0) {
							System.out.println("Extra Brackets");
							return false;
						}
						if(c == ')' && t == '(') {
							break;
						} else if(c=='}' && t=='{') {
							break;
						} else if (c==']' && t=='[') {
							break;
						}
					}
					
					count++;
				}
			}
		}
		
	while(!st.isEmpty()) {
		char t = st.pop().toString().charAt(0);
		if(t =='(' || t == '{' || t == '['){
			return false;
		}
	}
	
	return true;
		
	}

Use a stack:

We loop through the string. If we encounter an open parenthesis, we put it on the stack. If we find a close parenthesis, we remove an open parenthesis of the stack- In this case, if we find that there is no open parenthesis on the stack, we know that we have invalid parentheses.
Likewise, If we find that by the end of the string, we still have open parentheses on the stack, it is invalid.

Some code:

boolean isValid(String s) {

     Stack stack = new Stack();

     for (int i = 0; i < s.length(); i++) {

          if (s[i] == '(') { stack.push("("); }

               else if (s[i] == ')') {

                    if ( stack.size() > 0) { stack.pop();}
                    else { return false; }
               }
     }

     return (stack.size() == 0);
}

bool IsValidParenthesis(char* expression)
{
stack<char> parenthesis;
char* start = expression;
bool consecutive_push_flag = false;
bool consecutive_pop_flag = false;

while (*start != '\0')
{
if (*start == '(')
{
if (consecutive_push_flag == true)
{
parenthesis.push('#');
}
parenthesis.push(*start);
consecutive_push_flag = true;
consecutive_pop_flag = false;
}
else if (*start == ')')
{
if (parenthesis.empty())
{
return false;
}
if (consecutive_pop_flag == true && parenthesis.top() == '#')
{
return false;
}
consecutive_push_flag = false;
consecutive_pop_flag = true;
parenthesis.pop();
}
else
{
consecutive_push_flag = false;
consecutive_pop_flag = false;
}
++start;
}

if (!parenthesis.empty())
{
return false;
}

return true;
}

bool IsValidParenthesis(char* expression)
{
	stack<char> parenthesis;
	char* start = expression;
	bool consecutive_push_flag = false;
	bool consecutive_pop_flag = false;

	while (*start != '\0')
	{
		if (*start == '(')
		{
			if (consecutive_push_flag == true)
			{
				parenthesis.push('#');
			}
			parenthesis.push(*start);
			consecutive_push_flag = true;
			consecutive_pop_flag = false;
		}
		else if (*start == ')')
		{
			if (parenthesis.empty())
			{
				return false;
			}
			if (consecutive_pop_flag == true && parenthesis.top() == '#')
			{
				return false;
			}
			consecutive_push_flag = false;
			consecutive_pop_flag = true;
			parenthesis.pop();
		}
		else
		{
			consecutive_push_flag = false;
			consecutive_pop_flag = false;
		}
		++start;
	}

	if (!parenthesis.empty())
	{
		return false;
	}

	return true;

}

I do not understand why people are using stack to store braces and count. Why dont you just do one iteration of string and get the result without taking any additional data structure.
Let me know if my approach is slower than the one with stack. I have just started solving questions.

var exp = "((Hello))))))))))))))))";

var openBrCt = 0;
var closeBrCt = 0;



for (var i=0; i<exp.length; i++)
{
	if(exp[i]==='(')
		openBrCt++;
  else if(exp[i]===')')
  	closeBrCt++;   
}

if(openBrCt-closeBrCt == 0)
	alert("No error in expression");
else
	alert("Open and Close:" + openBrCt + "  " + closeBrCt)
	alert("There are: " + (parseInt(openBrCt)-parseInt(closeBrCt)) + " wrong braces in expression")

What if the expression is )A( ? Is the code expected to catch this issue?

import java.util.Stack;


public class Main {
public static void main(String[] args) {
String s = "(((((A))((B))))(()))";
System.out.println("isBalanced: " + isBalanced(s));
}

private static boolean isBalanced(String s) {
Stack<Character> sk = new Stack<Character>();
boolean bNeverHad = true;
for (char c: s.toCharArray()) {
if ((c != ')') && (c != '}') && (c != ']')) {
// ( ( A ( B
if (!bNeverHad && sk.isEmpty()) {
return false;
}
sk.push(c);
bNeverHad = false;
System.out.println("push: " + c);
} else {
// )
char popc;
if (!sk.isEmpty()) {
popc = sk.pop();
System.out.println(" POP: " + popc);
while ((!sk.isEmpty()) &&
(popc != '(') && (popc != '{') && (popc != '[')) {
popc = sk.pop();
System.out.println(" POP: " + popc);
break;
}
} else {
return false;
}
}
} // for
if (sk.size() > 0)
return false;
return true;
}

/* (non-Java-doc)
* @see java.lang.Object#Object()
*/
public Main() {
super();
}

}