Can be solved in one line:

    String input=sc.next();
    while(input.length() != (input = input.replaceAll("\\(\\)|\\[\\]|\\{\\}", "")).length());
    System.out.println(input.isEmpty());

But no stack used for this :)

This one was a bit tricky. You can't just check if this character is equal to what's on the stack because it must be the opposite bracket, parenthese, etc. for it to be "equally bracketed." You also have to make sure that the stack isn't empty before you peek -> or else you get a null-pointer.

Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
     String input=sc.next();
     Stack<Character> stacky = new Stack<>();
     for (int i = 0; i < input.length(); i++) {
        if (!stacky.isEmpty()) {
            switch(input.charAt(i)) {
                case '}' : if (stacky.peek() == '{') {
                    stacky.pop();
                } break;
                case ']' : if (stacky.peek() == '[') {
                    stacky.pop();
                } break;
                case ')' : if (stacky.peek() == '(') {
                    stacky.pop();
                } break;
                default: stacky.push(input.charAt(i));
          }
        } else {
            stacky.push(input.charAt(i));
        } 
     }
     System.out.println(stacky.isEmpty());
  }

Java scalable solution using HashMap

From my HackerRank solutions.

ArrayDeque is "likely to be faster than Stack when used as a stack" - Java documentation

import java.util.Scanner;
import java.util.HashMap;
import java.util.ArrayDeque;

class Solution {
    public static void main(String[] args) {
        /* Create HashMap to match opening brackets with closing brackets */
        HashMap<Character, Character> map = new HashMap<>();
        map.put('(', ')');
        map.put('[', ']');
        map.put('{', '}');
        
        /* Test each expression for validity */
        Scanner scan = new Scanner(System.in);
        while (scan.hasNext()) {
            String expression = scan.next();
            System.out.println(isBalanced(expression, map) ? "true" : "false" );
        }
        scan.close();
    }
    
    private static boolean isBalanced(String expression, HashMap<Character, Character> map) {
        if ((expression.length() % 2) != 0) {
            return false; // odd length Strings are not balanced
        }        
        ArrayDeque<Character> deque = new ArrayDeque<>(); // use deque as a stack
        for (int i = 0; i < expression.length(); i++) {
            Character ch = expression.charAt(i);
            if (map.containsKey(ch)) {
                deque.push(ch);
            } else if (deque.isEmpty() || ch != map.get(deque.pop())) {
                return false;
            }
        }
        return deque.isEmpty();
    }
}

Let me know if you have any questions.

Hi , i will have to say somthing here that the question is not clear , what is meant by " A is correct , AB are correct"

generally most of the questions lacks clarity !

best regards Anas

my simple solution import java.util.*; class Solution{

public static void main(String []argh)
{
    Scanner sc = new Scanner(System.in);
    Stack<Character> stack=new Stack<>();

    while (sc.hasNext()) {
        String input=sc.next();
        //Complete the code
        char[] c=input.toCharArray();
        for(char a:c)
        {
            if(a=='['||a=='('||a=='{')
            {
                stack.push(a);
                continue;
            }
            if(a==']'&&!stack.empty()&&stack.peek()=='[')
            {
                stack.pop();
                continue;
            }
            if(a==')'&&!stack.empty()&&stack.peek()=='(')
            {
                    stack.pop();
                    continue;
            }
            if(a=='}'&&!stack.empty()&&stack.peek()=='{')
            {
                stack.pop();
                continue;
            }
            if(a==']'||a==')'||a=='}')
            {
                stack.push(a);
                break;
            }
        }
        System.out.println(stack.isEmpty());
        stack.clear();

    }

}

}