# Find index of closing bracket for a given opening bracket in an expression

• Difficulty Level : Easy
• Last Updated : 10 Jan, 2019

Given a string with brackets. If the start index of the open bracket is given, find the index of the closing bracket.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

```Input : string = [ABC]
index = 0
Output : 8
The opening bracket at index 0 corresponds
to closing bracket at index 8.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The idea is to use Stack data structure. We traverse given expression from given index and keep pushing starting brackets. Whenever we encounter a closing bracket, we pop a starting bracket. If stack becomes empty at any moment, we return that index.

## C++

 `// CPP program to find index of closing``// bracket for given opening bracket.``#include ``using` `namespace` `std;`` ` `// Function to find index of closing``// bracket for given opening bracket.``void` `test(string expression, ``int` `index){``    ``int` `i;``     ` `    ``// If index given is invalid and is ``    ``// not an opening bracket.``    ``if``(expression[index]!=``'['``){``        ``cout << expression << ``", "` `<<``                    ``index << ``": -1\n"``;``        ``return``;``    ``}``     ` `    ``// Stack to store opening brackets.``    ``stack <``int``> st;``     ` `    ``// Traverse through string starting from``    ``// given index.``    ``for``(i = index; i < expression.length(); i++){``         ` `        ``// If current character is an ``        ``// opening bracket push it in stack.``        ``if``(expression[i] == ``'['``)``          ``st.push(expression[i]);``         ` `        ``// If current character is a closing``        ``// bracket, pop from stack. If stack ``        ``// is empty, then this closing``        ``// bracket is required bracket.``        ``else` `if``(expression[i] == ``']'``){``            ``st.pop();``            ``if``(st.empty()){``                ``cout << expression << ``", "` `<< ``                       ``index << ``": "` `<< i << ``"\n"``;``                ``return``;``            ``}``        ``}``    ``}``     ` `    ``// If no matching closing bracket``    ``// is found.``    ``cout << expression << ``", "` `<<``                ``index << ``": -1\n"``;``}`` ` `// Driver Code``int` `main() {``    ``test(``"[ABC]"``, 0); ``// should be 8``    ``test(``"[ABC]"``, 4); ``// should be 7``    ``test(``"[ABC]"``, 9); ``// should be 12``    ``test(``"[ABC]"``, 1); ``// No matching bracket``    ``return` `0;``}`` ` `// This code is contributed by Nikhil Jindal.`

## Java

 `// Java program to find index of closing ``// bracket for given opening bracket. ``import` `java.util.Stack;``class` `GFG {`` ` `// Function to find index of closing ``// bracket for given opening bracket. ``    ``static` `void` `test(String expression, ``int` `index) {``        ``int` `i;`` ` `        ``// If index given is invalid and is ``        ``// not an opening bracket. ``        ``if` `(expression.charAt(index) != ``'['``) {``            ``System.out.print(expression + ``", "``                    ``+ index + ``": -1\n"``);``            ``return``;``        ``}`` ` `        ``// Stack to store opening brackets. ``        ``Stack st = ``new` `Stack<>();`` ` `        ``// Traverse through string starting from ``        ``// given index. ``        ``for` `(i = index; i < expression.length(); i++) {`` ` `            ``// If current character is an ``            ``// opening bracket push it in stack. ``            ``if` `(expression.charAt(i) == ``'['``) {``                ``st.push((``int``) expression.charAt(i));``            ``} ``// If current character is a closing ``            ``// bracket, pop from stack. If stack ``            ``// is empty, then this closing ``            ``// bracket is required bracket. ``            ``else` `if` `(expression.charAt(i) == ``']'``) {``                ``st.pop();``                ``if` `(st.empty()) {``                    ``System.out.print(expression + ``", "``                            ``+ index + ``": "` `+ i + ``"\n"``);``                    ``return``;``                ``}``            ``}``        ``}`` ` `        ``// If no matching closing bracket ``        ``// is found. ``        ``System.out.print(expression + ``", "``                ``+ index + ``": -1\n"``);``    ``}`` ` `// Driver Code ``    ``public` `static` `void` `main(String[] args) {``        ``test(``"[ABC]"``, ``0``); ``// should be 8 ``        ``test(``"[ABC]"``, ``4``); ``// should be 7 ``        ``test(``"[ABC]"``, ``9``); ``// should be 12 ``        ``test(``"[ABC]"``, ``1``); ``// No matching bracket ``    ``}``// this code is contributed by Rajput-Ji``}`

## Python

 `# Python program to find index of closing``# bracket for a given opening bracket.``from` `collections ``import` `deque`` ` `def` `getIndex(s, i):`` ` `    ``# If input is invalid.``    ``if` `s[i] !``=` `'['``:``        ``return` `-``1`` ` `    ``# Create a deque to use it as a stack.``    ``d ``=` `deque()`` ` `    ``# Traverse through all elements``    ``# starting from i.``    ``for` `k ``in` `range``(i, ``len``(s)):`` ` `        ``# Pop a starting bracket``        ``# for every closing bracket``        ``if` `s[k] ``=``=` `']'``:``            ``d.popleft()`` ` `        ``# Push all starting brackets``        ``elif` `s[k] ``=``=` `'['``:``            ``d.append(s[i])`` ` `        ``# If deque becomes empty``        ``if` `not` `d:``            ``return` `k`` ` `    ``return` `-``1`` ` `# Driver code to test above method.``def` `test(s, i):``    ``matching_index ``=` `getIndex(s, i)``    ``print``(s ``+` `", "` `+` `str``(i) ``+` `": "` `+` `str``(matching_index))`` ` `def` `main():``    ``test(``"[ABC]"``, ``0``) ``# should be 8``    ``test(``"[ABC]"``, ``4``) ``# should be 7``    ``test(``"[ABC]"``, ``9``) ``# should be 12``    ``test(``"[ABC]"``, ``1``) ``# No matching bracket`` ` `if` `__name__ ``=``=` `"__main__"``:``    ``main()`

## C#

 `// C# program to find index of closing ``// bracket for given opening bracket. ``using` `System;``using` `System.Collections;``public` `class` `GFG { `` ` `// Function to find index of closing ``// bracket for given opening bracket. ``    ``static` `void` `test(String expression, ``int` `index) { ``        ``int` `i; `` ` `        ``// If index given is invalid and is ``        ``// not an opening bracket. ``        ``if` `(expression[index] != ``'['``) { ``            ``Console.Write(expression + ``", "``                    ``+ index + ``": -1\n"``); ``            ``return``; ``        ``} `` ` `        ``// Stack to store opening brackets. ``        ``Stack st = ``new` `Stack(); `` ` `        ``// Traverse through string starting from ``        ``// given index. ``        ``for` `(i = index; i < expression.Length; i++) { `` ` `            ``// If current character is an ``            ``// opening bracket push it in stack. ``            ``if` `(expression[i] == ``'['``) { ``                ``st.Push((``int``) expression[i]); ``            ``} ``// If current character is a closing ``            ``// bracket, pop from stack. If stack ``            ``// is empty, then this closing ``            ``// bracket is required bracket. ``            ``else` `if` `(expression[i] == ``']'``) { ``                ``st.Pop(); ``                ``if` `(st.Count==0) { ``                    ``Console.Write(expression + ``", "``                            ``+ index + ``": "` `+ i + ``"\n"``); ``                    ``return``; ``                ``} ``            ``} ``        ``} `` ` `        ``// If no matching closing bracket ``        ``// is found. ``        ``Console.Write(expression + ``", "``                ``+ index + ``": -1\n"``); ``    ``} `` ` `// Driver Code ``    ``public` `static` `void` `Main() { ``        ``test(``"[ABC]"``, 0); ``// should be 8 ``        ``test(``"[ABC]"``, 4); ``// should be 7 ``        ``test(``"[ABC]"``, 9); ``// should be 12 ``        ``test(``"[ABC]"``, 1); ``// No matching bracket ``    ``} ``} `` ` `// This code is contributed by 29AjayKumar`` `

Output:

```[ABC], 0: 8
[ABC], 4: 7
[ABC], 9: 12
[ABC], 1: -1
```

Time Complexity: O(n)
Auxiliary Space: O(n)

My Personal Notes arrow_drop_up