We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
  1. Prepare
  2. Java
  3. Data Structures
  4. Java Stack
  5. Discussions

Java Stack

Sort by

recency

|

653 Discussions

|

  • seelampavan99
     + 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");
    }
}

    }

  • nelsonmmatos
     + 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();
}

    }

  • bdeesorn
     + 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);
		}
		
	}
}

  • spriyamalar
     + 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);
    }

    }