Balanced Brackets HackerRank Solution

Balanced Brackets HackerRank Solution
Source : https://www.hackerrank.com/challenges/balanced-brackets

A bracket is considered to be any one of the following characters: (, ), {, }, [, or ].

Two brackets are considered to be a matched pair if the an opening bracket (i.e., (, [, or {) occurs to the left of a closing bracket (i.e., ), ], or }) of the exact same type. There are three types of matched pairs of brackets: [], {}, and ().

A matching pair of brackets is not balanced if the set of brackets it encloses are not matched. For example, {[(])} is not balanced because the contents in between { and } are not balanced. The pair of square brackets encloses a single, unbalanced opening bracket, (, and the pair of parentheses encloses a single, unbalanced closing square bracket, ].

By this logic, we say a sequence of brackets is balanced if the following conditions are met:

• It contains no unmatched brackets.
• The subset of brackets enclosed within the confines of a matched pair of brackets is also a matched pair of brackets.

Given strings of brackets, determine whether each sequence of brackets is balanced. If a string is balanced, return YES. Otherwise, return NO.

Function Description

Complete the function isBalanced in the editor below. It must return a string: YES if the sequence is balanced or NO if it is not.

isBalanced has the following parameter(s):

• s: a string of brackets

Input Format

The first line contains a single integer , the number of strings.
Each of the next lines contains a single string , a sequence of brackets.

Constraints

• , where is the length of the sequence.
• All chracters in the sequences ∈ { {, }, (, ), [, ] }.

Output Format

For each string, return YES or NO.

Sample Input

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

Sample Output

YESNOYES

Explanation

1. The string {[()]} meets both criteria for being a balanced string, so we print YES on a new line.
2. The string {[(])} is not balanced because the brackets enclosed by the matched pair { and } are not balanced: [(]).
3. The string {{[[(())]]}} meets both criteria for being a balanced string, so we print YES on a new line.

Source : https://www.hackerrank.com/challenges/balanced-brackets

Solution

	// Karthikalapati.blogspot.com
	import java.util.Scanner;
	import java.util.HashMap;
	import java.util.ArrayDeque;
	// ArrayDeque is "likely to be faster than Stack when used as a stack" - Java documentation
	// Time Complexity: O(n)
	// Space Complexity: O(n)
	public 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);
	int t = scan.nextInt();
	while (t-- > 0) {
	String expression = scan.next();
	System.out.println(isBalanced(expression, map) ? "YES" : "NO" );
	}
	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();
	}
	}