Sort by

recency

|

653 Discussions

|

  • + 0 comments

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

    public class Solution {

    public static void main(String[] args) {
        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
        Scanner scan = new Scanner(System.in);
    
    
        while(scan.hasNext()) {
        Stack<Character> data = new Stack<>();
        String str = scan.next();
            for(int i = 0;i<str.length();i++) {
                char c = str.charAt(i);
                if(data.isEmpty()) {
                    data.push(c);
                    continue;
                }
    
                if(data.peek() == '{' && c == '}' || data.peek() == '(' && c == ')' || data.peek() == '[' && c == ']') data.pop();
                else data.push(c);
            }
            System.out.println(data.isEmpty()?"true":"false");
        }
    }
    

    }

  • + 0 comments

    import java.util.*; class Solution{

    public static void main(String []argh)
    {
        Scanner sc = new Scanner(System.in);
    
        while (sc.hasNext()) {
            String input=sc.next();
            Stack<Character> s = new Stack<>();
            for(int i = 0; i < input.length(); i++){
                char c = input.charAt(i);
                if(s.isEmpty()) s.add(c);
                else{
                    char top_c = s.peek();
                    if((top_c == '{' && c == '}') || (top_c == '(' && c == ')') 
                        || (top_c == '[' && c == ']'))
                        s.pop();
                    else s.add(c);
                }        
            }
    
            if(s.isEmpty()) System.out.println("true");
            else System.out.println("false");
        }
    
        sc.close();
    }
    

    }

  • + 0 comments
    private static boolean isMatch(String line) {
            if (line.length()%2 != 0) {
                return false;
            }
            
            Stack<Integer> intStack = new Stack<>();
            for (char c : line.toCharArray()) {
                switch (c) {
                    case '[':
                        intStack.push(1);
                        break;
                    case '{':
                        intStack.push(2);
                        break;
                    case '(':
                        intStack.push(3);
                        break;
                    case ')':
                        intStack.push(4);
                        break;
                    case '}':
                        intStack.push(5);
                        break;
                    case ']':
                        intStack.push(6);
                        break;
                    default:
                        //
                }
            }
            
            Stack<Integer> leftoverStack = new Stack<>();
            
            while (intStack.size() > 0) {
                if (leftoverStack.isEmpty()) {
                    leftoverStack.push(intStack.pop());
                } else {
                    if (intStack.peek() + leftoverStack.peek() == 7 &&
                            intStack.peek() < leftoverStack.peek()) {
                        intStack.pop();
                        leftoverStack.pop();
                    } else {
                        leftoverStack.push(intStack.pop());
                    }
                }
            }
            
            return leftoverStack.isEmpty();
        }
    
  • [deleted]
    + 0 comments
    import java.util.*;
    class Solution{
    	
    	public static void main(String []argh)
    	{
    		Scanner sc = new Scanner(System.in);
            
            Map<Character, Character> parentheses = new HashMap<>();
            parentheses.put(')', '(');
            parentheses.put(']', '[');
            parentheses.put('}', '{');
            
    		while (sc.hasNext()) {
    			String input = sc.next();
                boolean isBalanced = true;
                
                Stack<Character> stack = new Stack<>();
                
                for (int i = 0; i < input.length(); i++) {
                    char c = input.charAt(i);
                
                    if (c == '(' || c == '[' || c == '{') {
                        stack.add(c);
                    } else {
                        if (stack.isEmpty() || stack.pop() != parentheses.get(c)) {
                            isBalanced = false;
                            break;
                        }
                    }
                }
                
                if (!stack.isEmpty()) {
                    isBalanced = false;
                }
                System.out.println(isBalanced);
    		}
    		
    	}
    }
    
  • + 0 comments
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String input=sc.next();
            boolean valid = input.length() % 2 == 0;
            Stack<Character> charStack = new Stack<>();
            for(int i=0; valid && i<input.length();i++) {
                Character c = input.charAt(i);
                if(List.of('[', '{', '(').contains(c)) {
                    charStack.push(c);
                } else {
                    if(charStack.isEmpty()) {
                        valid = false;
                        break;
                    }
                    Character p = charStack.pop();
                    if((c == '}' && p != '{') || 
                       (c == ']' && p != '[') ||
                       (c == ')' && p != '(')) {
                        valid = false;
                        break;
                    }
                }
            }
            if(!charStack.isEmpty()) valid = false;
            System.out.println(valid ? true : false);
        }
    

    }