Question

//C++

Problem description

In this problem, we consider expressions containing brackets that are properly nested. These expressions are obtained by juxtaposition of properly nested expressions in a pair of matching brackets, the left one an opening and the right one a closing bracket.

( a + $ ( b = ) ( a ) )         is properly nested
( a + $ ) b = ) ( a ( )         is not

In this problem we have several pairs of brackets, so we have to impose a second condition on the expression: the matching brackets should be of the same kind. Consequently '(())' is okay, but '([))' is not. The pairs of brackets are:

(       )
[       ]
{       }
<    >
(*      *)

The two characters '(*' should be interpreted as one symbol, not as an opening bracket '(' followed immediately by an asterisk, and similarly for '*)'.

Write a C++ program that checks whether expressions are properly nested. If the expression is not properly nested, your program should determine the position of the offending bracket, that is the length of the shortest prefix of the expression that can not be extended to a properly nested expression. Don't forget '(*' counts as one, as does '*)'. the characters that are not brackets also count as one.

I expect you to make full use of the STL in your solution to this problem (i.e., your first choice should be to make use of existing functionality provided by the STL). Hint: the std::stack template class is handy.

This program should be fully documented (as required by the syllabus) and neatly and consistently formatted. Grading on these will be strictly enforced.

Input specification

The input is read from the standard input stream. Each line contains an expression to be checked followed by an end-of-line marker. No line contains more than 3000 characters. The input ends with a standard end-of-file marker.

Output specification

The output is written to the standard output stream. Each line contains the result of the check of the corresponding input line, that is 'YES' (in upper case), if the expression is okay, and 'NO' (in upper case) if the expression is not okay. This is followed by a space and the position of the error.

Sample input

(*a++(*)
(*a{+}*)

Sample output

NO 6
YES

Answer 1

Find the code for the above question below, read the comments provided in the code for better understanding. If found helpful please do upvote this.
Please refer to the screenshot of the code to understand the indentation of the code.

Copyable Code

#include <iostream> //standard c++ header file

#include <stack>    //for stack operations

using namespace std;

//this method returns a positive integer if error is found

//else a negative number -1

int BalanceCheck(string exp)

{

    //stack to hold the brackets

    stack<char> s;

    char x;

    int last_brack=-1;//to store the index of last opening bracket

    //loop through the expression

    for (int i = 0; i < exp.length(); i++)

    {

        //if the current elemenet is a opening bracket

        //push it into the stack

        if (exp[i] == '(' || exp[i] == '[' || exp[i] == '{')

        {

            s.push(exp[i]);

            last_brack=i;

            continue;

        }

        //if the current element is  closing bracket

        switch (exp[i])

        {

            //if the element is closing bracket the  get the top of stack and

            //match it

        case ')':

            x = s.top();

            s.pop();

            if (x == '{' || x == '[')

                return last_brack;

            break;

        case '}':

            x = s.top();

            s.pop();

            if (x == '(' || x == '[')

                return last_brack;

            break;

        case ']':

            x = s.top();

            s.pop();

            if (x == '(' || x == '{')

                return last_brack;

            break;

        }

    }

    //if the stack is empty

    if (s.empty())

        return -1;

    else

        return last_brack;

}

//main driver code of the porgram

int main()

{

    string exp = "(*a++(*)";

    //call method to check balanced or not

    int ind = BalanceCheck(exp);

    //if value returned is negative then it's balanced else not

    if(ind>=0){

        //ind +1 because array indexing starts from 0

        cout<<"NO "<<ind+1<<"\n";

    }

    else

        cout<<"YES\n";

    return 0;

}

Screenshot

char x; { 1 #include <iostream> //standard c++ header file 2 #include <stack> //for stack operations 3 4 using namespace std; 5 6 //this method returns a positive integer if error is found 7l/else a negative number -1 8 int BalanceCheck(string exp) 9{ 10 //stack to hold the brackets 11 stack<char> s; 12 13 int last_brack=-1;//to store the index of last opening bracket 14 15 // loop through the expression 16 for (int i = 0; i < exp.length(); i++) 17 { 18 //if the current elemenet is a opening bracket 19 //push it into the stack 20 if (exp[i] "(" || exp[i] == '[' || exp[i] == '{') 21 { 22 s.push(exp[i]); 23 last_brack=i; 24 continue; 25 } 26 27 //if the current element is closing bracket 28 switch (exp[i]). 29 30 //if the element is closing bracket the get the top of stack and 31 //match it 32 case ')': 33 X = s.top(); 34 s.pop(); 35 if (x == '{' || X == '[') 36 return last_brack; 37 break; 38 case '}': 39 X = s.top(); 40 s.pop(); 41 if (x == '(' || X == '[') 42 return last_brack; 43 break; 44 case ']': 45 X = s.top(); 46 s.pop(); 47 if (x '(' || X == '{') 48 return last_brack; 49 break; 50 } 51 } 52 53 //if the stack is empty 54 if (s.empty()) 55 return -1; 56 else 57 return last_brack; 58 } 59 60 //main driver code of the porgram 61 int main(). 62 { 63 64 string exp = "(*a++(*)"; 65 66 //call method to check balanced or not 67 int ind BalanceCheck(exp); 68 //if value returned is negative then it's balanced else not 69 if(ind>=0){ 70 //ind +1 because array indexing starts from 0 71 cout<<"NO"<<ind+l<<"\n"; 72 } 73 else 74 cout<<"YES\n"; 75 return 0; 76 } 77

Output

NO 6