main.cpp

#include <iostream>
#include <stack>
#include <string>
using namespace std;

bool isBalanced(const string& expression, int& errorPosition)
{
    stack<pair<char, int>> st;

    for (int i = 0; i < expression.length(); i++)
    {
        char ch = expression[i];

        // Opening bracket
        if (ch == '(' || ch == '[' || ch == '{')
        {
            st.push({ch, i});
        }

        // Closing bracket
        else if (ch == ')' || ch == ']' || ch == '}')
        {
            // Closing bracket found but no opening bracket exists
            if (st.empty())
            {
                errorPosition = i;
                return false;
            }

            char top = st.top().first;

            // Check matching pair
            if ((ch == ')' && top == '(') ||
                (ch == ']' && top == '[') ||
                (ch == '}' && top == '{'))
            {
                st.pop();
            }
            else
            {
                errorPosition = i;
                return false;
            }
        }
    }

    // Some opening bracket was never closed
    if (!st.empty())
    {
        errorPosition = st.top().second;
        return false;
    }

    return true;
}

int main()
{
    string expression;
    int errorPosition = -1;
    bool hasBracket = false;

    cout << "================================\n";
    cout << "  BALANCED PARENTHESES CHECKER\n";
    cout << "================================\n";

    cout << "\nEnter an expression: ";
    getline(cin, expression);

    // Empty input
    if (expression.empty())
    {
        cout << "\nInvalid input! Expression cannot be empty.\n";
        return 0;
    }

    // Check whether input contains at least one bracket
    for (char ch : expression)
    {
        if (ch == '(' || ch == ')' ||
            ch == '[' || ch == ']' ||
            ch == '{' || ch == '}')
        {
            hasBracket = true;
            break;
        }
    }

    if (!hasBracket)
    {
        cout << "\nInvalid input! No brackets found.\n";
    }
    else if (isBalanced(expression, errorPosition))
    {
        cout << "\nExpression is BALANCED\n";
    }
    else
    {
        cout << "\nExpression is NOT BALANCED\n";
        cout << "Error at position: " << errorPosition << "\n";
    }

    return 0;
}