You've successfully subscribed to The Poor Coder | Hackerrank Solutions
Great! Next, complete checkout for full access to The Poor Coder | Hackerrank Solutions
Welcome back! You've successfully signed in.
Success! Your account is fully activated, you now have access to all content.
Hackerrank Java Stack Solution

Hackerrank Java Stack Solution

Beeze Aal
Beeze Aal
In computer science, a stack or LIFO (last in, first out) is an abstract data type that serves as a collection of elements, with two principal operations: push, which adds an element to the collection, and pop, which removes the last element that was added.(Wikipedia)

A string containing only parentheses is balanced if the following is true: 1. if it is an empty string 2. if A and B are correct, AB is correct, 3. if A is correct, (A) and {A} and [A] are also correct.

Examples of some correctly balanced strings are: "{}()",  "[{()}]",  "({()})"

Examples of some unbalanced strings are: "{}(",  "({)}",  "[[",  "}{" etc.

Given a string, determine if it is balanced or not.

Input Format

There will be multiple lines in the input file, each having a single non-empty string. You should read input till end-of-file.

The part of the code that handles input operation is already provided in the editor.

Output Format

For each case, print 'true' if the string is balanced, 'false' otherwise.

Sample Input

{}()
({()})
{}(
[]

Sample Output

true
true
false
true

Solution in java8

Approach 1.

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

public class Solution {
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while(sc.hasNext()) {
			String input = sc.next();
			System.out.println(balanaced(input));
		}
	}
	
	public static boolean balanaced(String s) {
		Stack<Character> stack = new Stack<Character>();
		for(int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);
			if(c =='[' || c == '(' || c == '{') {
				stack.push(c);
			}else if(c == ']') {
				if(stack.isEmpty() || stack.pop() != '[') {
					return false;
				}
			}else if(c == ')') {
				if(stack.isEmpty() || stack.pop() != '(') {
					return false;
				}
			}else if(c == '}') {
				if(stack.isEmpty() || stack.pop() != '{') {
					return false;
				}
			}
		}
		return stack.isEmpty();
	}
}

Approach 2.

import java.util.*;
class Solution{
   
   public static void main(String []argh)
   {
      Scanner sc = new Scanner(System.in);
      HashMap<Character,Character> map= new HashMap<>();
        map.put('(', ')');
        map.put('[', ']');
        map.put('{', '}');
       
      while (sc.hasNext()) {
         String input=sc.next();
         System.out.println(bam(input,map)? "true" : "false");
          
      }
      sc.close();
   }
    public static boolean bam(String a, HashMap<Character,Character> map)
    {
      if(a.length() % 2 != 0)
      {
         return false;
      }
        ArrayDeque<Character> ad = new ArrayDeque<Character>(); 
        for(int i=0; i<a.length(); i++)
        {
            Character c = a.charAt(i);
            if(map.containsKey(c))
            {
                ad.push(c);
            }
            else if (ad.isEmpty() || c!= map.get(ad.pop()))
            {
                return false;
            }
           
        }
        return true;
    }
}


Approach 3.

import java.util.*;

class Solution{
   
   public static void main(String []argh)
   {
      Scanner sc = new Scanner(System.in);
      
      while (sc.hasNext()) {
         String input=sc.next();
         System.out.println((balancedParenthensies(input)));
      }
      
   }
    
     public static boolean balancedParenthensies(String s) {
        Stack<Character> stack  = new Stack<Character>();
        for(int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if(c == '[' || c == '(' || c == '{' ) {     
                stack.push(c);
            } else if(c == ']') {
                if(stack.isEmpty() || stack.pop() != '[') {
                    return false;
                }
            } else if(c == ')') {
                if(stack.isEmpty() || stack.pop() != '(') {
                    return false;
                }           
            } else if(c == '}') {
                if(stack.isEmpty() || stack.pop() != '{') {
                    return false;
                }
            }

        }
        return stack.isEmpty();
    }
}