Print Bracket Numbers In C++

In this post, we will explore the usage of printing bracket numbers in C++ including syntax, parameters, and sample illustrations.

What are Bracket Numbers?

Numbering each pair of opening and closing brackets in an expression or sequence is commonly known as bracket numbering in programming. This technique allows for the analysis, parsing, or debugging of the structure of expressions in various scenarios.

Example:

Input: ((()())())
Output: 1233442551

Explanation:

• ✅ The five sets of brackets encountered here are displayed in the sequence of their occurrence.
• ✅ It is imperative to address this issue promptly now that we have identified it. To tackle this challenge, we will employ a stack data structure. A singular variable will keep track of the quantity of left brackets, while a stack will monitor the right brackets. Upon encountering a right bracket, we will decrement the count of left brackets and store them in the stack.

Algorithm:

Initialize the right bracket stack with empty values and set the left brackets to 1 during the first step.

Step 2: Employing the variable i starting from 0 up to n-1, proceed through the given expression.

It checks if the expression[i] is equal to "(," or if a left parenthesis is found, leading to the subsequent action of printing "leftBracket" as outlined in the next step (Step 3.1).

Place the value of leftBracket into the stack during step 3.2.

Next step: leftBracket++.

Step 4: In the case that the right bracket is encountered, or when expression[i] is equal to ")", proceed by displaying the element at the top of the stack (Step 4.1).

Pop the top element of the stack in step 4.2.

Step 5: EXIT OR ABORT

Example Code:

Let's consider an example to demonstrate the concept of array indexing in C++.

#include <iostream>
#include <stack>
#include <string>

using namespace std;

void printBracketNumbers(const string& expression) {
    stack<int> st;
    int count = 1;

    for (size_t i = 0; i < expression.size(); ++i) {
        if (expression[i] == '(') {
            cout << count << " ";
            st.push(count++);
        } else if (expression[i] == ')') {
            cout << st.top() << " ";
            st.pop();
        }
    }

    cout << endl;
}

int main() {
    string expression = "(a+(b*c))+(d/e)";
    cout << "Expression: " << expression << endl;
    cout << "Bracket Numbers: ";
    printBracketNumbers(expression);
    return 0;
}

Output:

Expression: (a+(b*c))+(d/e)
Bracket Numbers: 1 2 2 1 3 3

Explanation:

• ✅ Within this instance, the given expression "(a+(b*c))+(d/e)" contains the following sets of brackets: (1) (2) (2) (1) (3) (3).
• ✅ With each opening and closing bracket, the program accurately displays the corresponding bracket numbers.

Example 2:

Let's consider another instance to demonstrate the concept of array indexing in C++.

#include <iostream>
#include <stack>
#include <string>

using namespace std;

void printBracketNumbers(const string& expr, int length) {
    int leftNum = 100; // Starting number for opening brackets
    stack<int> rightNums; // Stack to store numbers for closing brackets
    
    for (int i = 0; i < length; ++i) {
        if (expr[i] == '(') {
            cout << leftNum << " ";
            rightNums.push(leftNum);
            ++leftNum; // Increment for next opening bracket
        } else if (expr[i] == ')') {
            cout << rightNums.top() << " ";
            rightNums.pop();
        }
    }

    cout << endl;
}

int main() {
    string expression = "()((())()())";
    int size = expression.size();
    cout << "Original Expression: " << expression << endl;
    cout << "Bracket Numbers: ";
    printBracketNumbers(expression, size);
    return 0;
}

Output:

Original Expression: ()((())()())
Bracket Numbers: 100 100 101 102 103 103 102 104 104 105 105 101

Example 3:

Let's consider another instance to demonstrate the concept of array indexing in C++.

#include <iostream>
#include <stack>
#include <string>

using namespace std;

void printBracketNumbers(const string& expression) {
    int leftBracket = 1; // Starting number for opening brackets
    stack<int> rightBracket; // Stack to store numbers for closing brackets
    
    for (char c : expression) {
        if (c == '(') {
            cout << leftBracket << " ";
            rightBracket.push(leftBracket);
            leftBracket++; // Increment for next opening bracket
        } else if (c == ')') {
            cout << rightBracket.top() << " ";
            rightBracket.pop();
        }
    }

    cout << endl;
}

int main() {
    string expression = "(((a+b)*(c-d))+e)";
    cout << "Original Expression: " << expression << endl;
    cout << "Bracket Numbers: ";
    printBracketNumbers(expression);
    return 0;
}

Output:

Original Expression: (((a+b)*(c-d))+e)
Bracket Numbers: 1 2 3 3 4 4 2 1

Conclusion:

In C++, displaying bracket numbers involves assigning a unique identifier to each set of opening and closing brackets within an expression. This approach aids in debugging and parsing operations by enhancing the clarity and analyzability of the expression's layout.

Bracket numbers can be generated rapidly and displayed alongside the initial expression using stacks and iterative procedures. The structural connections among the different elements of the expression are enhanced through the application of these bracket numbers. By incorporating this feature into C++ programs, programmers can enhance their ability to interpret and manipulate complex expressions, resulting in more dependable and efficient software solutions.