A bracket is considered to be any one of the following characters: `(`

, `)`

, `{`

, `}`

, `[`

, or `]`

.

The coding problem is defined in Hacker Rank platform. The problem can expand your Data Structure knowledge, as well as can helps you to crack Interviews.

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 `()`

.

If the set of brackets it encloses are not matched, then a matching pair of brackets is *not balanced*. 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, `]`

.

If the below two conditions are matching then we can say that the sequence of brackets is balanced.

- 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 n 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.

isBalanced has the following parameter(s):

*string s*: a string of brackets

**Returns**

*string:*either`YES`

or`NO`

**Input Format**

The first line contains a single integer n, the number of strings.

Each of the next n lines contains a single string s, a sequence of brackets.

**Constraints**

1 <= n <= 10^3

1 <= |s| <= 10^3, where |s| is the length of the sequence.

All chracters in the sequences ∈ { **{**, **}**, **(**, **)**, **[**, **]** }.

**Output Format**

For each string, return `YES`

or `NO`

.

**Sample Input**

STDIN Function —– ——– 3 n = 3 {[()]} first s = ‘{[()]}’ {[(])} second s = ‘{[(])}’ {{[[(())]]}} third s ='{{[[(())]]}}’

**Sample Output**

```
YES
NO
YES
```

**Explanation**

- The string
`{[()]}`

meets both criteria for being a balanced string. - The string
`{[(])}`

is not balanced because the brackets enclosed by the matched pair`{`

and`}`

are not balanced:`[(])`

. - The string
`{{[[(())]]}}`

meets both criteria for being a balanced string.

Such a amazing 🤩