import java.io.; import java.util.;

public class Solution { // {}() [] public static boolean bracketBalanced(String str){ Stack stack=new Stack<>(); for(int i=0;i

}





public static void main(String[] args) {
    Scanner sc=new Scanner(System.in);
   while(sc.hasNext()){
       String str=sc.nextLine();
      System.out.println(bracketBalanced(str));

   }

    sc.close();

}

}

import java.util.Scanner; import java.util.Stack;

public class JavaStackParanthesis { public static void main(String[] argh) { Scanner sc = new Scanner(System.in); while (sc.hasNext()) { String input = sc.next(); System.out.println(validate(input)); } sc.close(); }

private static boolean validate(String str) {
    boolean isValid = false;
    if (str == null || str.length() % 2 != 0) {
        return false;
    }
    Stack<Character> stack = new Stack<>();
    char[] chr = str.toCharArray();

    for (char ch : chr) {
        if (ch == '{' || ch == '(' || ch == '[') {
            stack.push(ch);
        } else {
            if (!stack.isEmpty()) {
                char popCh = stack.pop();
                if (ch == '}') {
                    if (popCh == '{') {
                        continue;
                    }
                    break;
                } else if (ch == ']') {
                    if (popCh == '[') {
                        continue;
                    }
                    break;
                } else if (ch == ')') {
                    if (popCh == '(') {
                        continue;
                    }
                    break;
                }

            } else {
                return false;
            }

        }
    }
    if (stack.isEmpty()) {
        isValid = true;
    }

    return isValid;
}

}

My solution:

import java.util.*; class Solution{

public static void main(String []argh)
{
    Scanner sc = new Scanner(System.in);
    Solution sc2 = new Solution();
    HashMap<Character,Character> hm = new HashMap<>();
    hm.put('{','}');
    hm.put('[',']');
    hm.put('(',')');

    while (sc.hasNext()) {
        String input=sc.next();
        Stack<Character> tc = new Stack<>();
        System.out.println(sc2.isBalanced(tc,input,hm)); 
    }

}

public boolean isBalanced(Stack<Character> tc, String input, HashMap<Character,Character> hm){

    if ( input.length() %2 == 0){
         for (char a : input.toCharArray()){

            if (a=='{' || a=='[' || a=='('){
                tc.push(a);
            }else{
                if (tc.isEmpty()){
                    return false;
                }
             if ((a=='}' || a==']' || a==')')){
                 if(a==hm.get(tc.peek())){
                     tc.pop();
                 }  
             } 
             }
        }
    } 
    else return false;
    return tc.isEmpty();
}

}

java 8

import java.util.Scanner;

class Solution {

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    char[] arr = new char[100];  
    while (sc.hasNext()) {
        String input = sc.next();
        boolean isBalanced = true;
        int top = -1;

        for (int i = 0; i < input.length(); i++) {
            char ch = input.charAt(i);

            if (ch == '(' || ch == '{' || ch == '[')
                arr[++top] = ch; 
            else if (ch == ')' || ch == '}' || ch == ']') {
                if (top == -1) {
                    isBalanced = false;
                    break;
                }
                else {
                    if (!isMatchingPair(arr[top--], ch)) {
                        isBalanced = false;
                        break;
                    }
                }
            }
        }
        if (top != -1) {
            isBalanced = false;
        }
        System.out.println(isBalanced ? "true" : "false");
    }
    sc.close();
}

static boolean isMatchingPair(char open, char close) {
    return (open == '(' && close == ')') ||
           (open == '{' && close == '}') ||
           (open == '[' && close == ']');
}

}

java 8

	public static void main(String []argh)
	{
		Scanner sc = new Scanner(System.in);
		
		while (sc.hasNext()) {
			String input=sc.next();
            System.out.println(isBalanced(input));
		}
	}
    
    public static boolean isBalanced(String s) {
        Map<Character, Character> braketsMap = new HashMap<>();
        braketsMap.put('{', '}');
        braketsMap.put('(', ')');
        braketsMap.put('[', ']');
        
        Stack<Character> stack = new Stack<>();
        for (char ch: s.toCharArray()) {
            if (braketsMap.containsKey(ch)) {
                stack.add(ch);
            } else {
                if (stack.isEmpty()) {
                    return false;
                }
                char last = stack.pop();
                if (ch != braketsMap.get(last)) {
                    return false;
                }
            }
        }
        return stack.isEmpty();
    }