mycodeschool/BalancedParentheses.cpp

senthilnathan87 · 2019-08-26T18:35:22Z

Can you share the code in Java, I tried implementing the same logic in java but unable to develope one

import org.testng.Assert;
import org.testng.annotations.Test;
import java.util.Stack;
/**
 * ExpressionEvaluator
 */
public class ExpressionEvaluator {

    @Test
    public void expressionsTest() {
        Assert.assertTrue(BalancedExpressionAlg.isBalanced("{A+B}"));
        Assert.assertTrue(BalancedExpressionAlg.isBalanced("{ (C*9) * [10] - (A+B) }"));
        Assert.assertFalse(BalancedExpressionAlg.isBalanced("{ { () }"));
        Assert.assertTrue(BalancedExpressionAlg.isBalanced("{ as } (C*2)"));
        Assert.assertFalse(BalancedExpressionAlg.isBalanced("}{"));
    }
    
}

class BalancedExpressionAlg {

    // Works in O(n)
    static boolean isBalanced(String expr) {
        Stack<Character> stack = new Stack<>();
        char[] chars = expr.toCharArray();
        for(char ch : chars) {
            if(ch == '{' || ch == '[' || ch == '(') {
                stack.push(ch);
            }
            switch(ch) {
                case '}':
                    if(stack.isEmpty() || stack.pop() != '{') return false;
                break;
                case ']':
                    if(stack.isEmpty() || stack.pop() != '[') return false;
                break;
                case ')':
                    if(stack.isEmpty() || stack.pop() != '(') return false;
                break;                                 
            }

        }
        if(stack.isEmpty()) {
            return true;
        }
        return false;
    }
}

misterpoloy · 2020-01-10T19:24:11Z

This was my solution:

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

bool testBalance(std::string str) {
    std::stack<char> expressions;
    for (int i = 0; i < str.size(); i++) {
        char current = str[i];
        if (current == '{' || current == '[' || current == '(') {
            expressions.push(current);
            continue;
        }
        if (current == '}' || current == ']' || current == ')') {
            if (expressions.empty()) {
                return false;
            } else {
             // Compare the match
                char last = expressions.top();
                bool congruent = false;
                switch (last) {
                    case '{':
                        if (current == '}')
                            congruent = true;
                        break;
                    case '[':
                        if (current == ']')
                            congruent = true;
                        break;
                    case '(':
                        if (current == ')')
                            congruent = true;
                        break;
                    default:
                        break;
                }
                if (congruent) {
                    expressions.pop();
                } else {
                    return false;
                }
            }
        }
    }
    return expressions.empty();
};

int main() {
    std::string str;
    getline(std::cin, str);
    std::cout << testBalance(str) << std::endl;
    return 0;
}

asad2200 · 2020-04-21T02:25:46Z

Here the java code ,if someone wants

//------------------------------------

import java.util.Scanner;
import java.util.Stack;

public class CheckParathese {

static boolean checkPair(char opening,char closing){
    if(opening == '(' && closing == ')') return true;
    else if(opening == '{' && closing == '}') return true;
    else if(opening == '[' && closing == ']') return true;
    return false;
}

static boolean isBalanced(String s) {
    char arr[] = s.toCharArray();
    Stack<Character> st = new Stack<Character>();
    for(int i=0;i<s.length();i++){
        if(arr[i] == '(' || arr[i] == '{' || arr[i] == '[')
            st.push(arr[i]);
        else if(arr[i] == ')' || arr[i] == '}' || arr[i] == ']'){
            if(st.empty() || !checkPair(st.peek(),arr[i])){
                return false;
            }else
                st.pop();
        }
    }
    return st.empty()?true:false ;
}

public static void main(String[] args) throws Exception {
    String s;
    Scanner sc = new Scanner(System.in);
    s=sc.nextLine();
    sc.close();
    if(isBalanced(s))
        System.out.print("Paranthases are balanced");
    else
        System.out.print("Paranthases are not balanced");   
}

}
//-------------------------------------

hitsa70 · 2020-04-29T09:48:57Z

import java.util.*;
public class Solution {

public static boolean matchingPeer(char open , char close){
if ( open == '(' && close == ')'){
return true;
}
if ( open == '[' && close == ']'){
return true;
}
if ( open == '{' && close == '}'){
return true;
}
// you can add more open and close rule

else{
return false;
}

}

public static boolean checkBalanced(String equation) 
{
	// Write your code here
	char[] c = equation.toCharArray();
Stack <Character> myStack= new Stack <Character> ();

for (int i = 0; i < c.length; i++)
{
	if(c[i]=='(' || c[i] == '[' || c[i] == '{'){
		myStack.push(c[i]);
        continue;
	}
	else if (c[i]== ')' || c[i]==']' || c[i] == '}'){
        	if(myStack.isEmpty())
                return false;
			if(matchingPeer(myStack.peek(),c[i]) == true){
				myStack.pop();
			
			} else {
				return false;
			}
	}
}
	if(myStack.isEmpty()){
		return true;
	}	
	else {
		return false;
	}
}

}

FredLeg · 2020-05-19T08:26:58Z

JAVASCRIPT

function isParanthesesBalanced( expression ){
  let symbols = {
      'opening': ['(','[','{','«'],
      'closing': [')',']','}','»'],
      'isOpening': function( car ){
        return this.opening.indexOf(car)>=0
      },
      'isClosing': function( car ){
        return this.closing.indexOf(car)>=0
      },
      'isPair': function( opening, closing ){
        let i = this.opening.indexOf(opening)
        if( !(i>=0) ) return false
        return i == this.closing.indexOf(closing)
      }
  }
  let stack = {
    's':       [],
    'push':    function( car ){ this.s.push(car) },
    'pop':     function( car ){ this.s.pop(car) },
    'top':     function(){ return this.s[this.s.length-1] },
    'isEmpty': function(){ return this.s.length==0 }
  }
  for ( let car of expression ) {
    if( symbols.isOpening(car) )
      stack.push(car)
    else if( symbols.isClosing(car) ){
      if( stack.isEmpty() || !symbols.isPair( stack.top(), car ) )
        return false
      else
        stack.pop()
    }
  }
  return stack.isEmpty()
}

let expressions = [
  "[(a+b)*(c+d)]",
  "[()(])",
  "Elle dit « ouh là là » tout le temps.",
  "none",
  ""
]
for( exp of expressions ){
  console.log( exp +" • "+ isParanthesesBalanced(exp) )
}

[(a+b)*(c+d)] • true
[()(]) • false
Elle dit « ouh là là » tout le temps. • true
none • true
 • true

siddharthmagadum16 · 2020-06-09T19:04:10Z

Here's my code. I implemented using stack . The stack is implemented using object oriented implementation using arrays.
`// Stack - ||Object oriented implementation|| using arrays
#include
using namespace std;
#define MAX_SIZE 4

class Stack
{
private:
int A[MAX_SIZE]; // array to store the stack
int top; // variable to mark the top index of stack.
public:
// constructor
Stack()
{
top = -1; // for empty array, set top = -1
}

// Push operation to insert an element on top of stack. 
void Push(int x) 
{
  if(top == MAX_SIZE -1) { // overflow case. 
		printf("Error: stack overflow\n");
		return;
	}
	A[++top] = x;
}

// Pop operation to remove an element from top of stack.
void Pop() 
{
	if(top == -1) { // If stack is empty, pop should throw error. 
		printf("Error: No element to pop\n");
		return;
	}
	top--;
}

// Top operation to return element at top of stack. 
int Top() 
{
	return A[top];
}

// This function will return 1 (true) if stack is empty, 0 (false) otherwise
int IsEmpty()
{
	if(top == -1) return 1;
	return 0;
}

// ONLY FOR TESTING - NOT A VALID OPERATION WITH STACK 
// This function is just to test the implementation of stack. 
// This will print all the elements in the stack at any stage. 
void Print() {
	int i;
	printf("Stack: ");
	for(i = 0;i<=top;i++)
		printf("%d ",A[i]);
	printf("\n");
}

};

int solve(){
Stack S;
char ch=getchar();
while(ch!='\n'){
if(ch=='{' || ch=='(' || ch=='['){
S.Push(ch);
}
else if(ch=='}' || ch==')' || ch==']'){
if(S.IsEmpty() || (S.Top()!='{' && ch=='}') || S.Top()!='(' && ch==')' || S.Top()!='[' && ch==']');
else S.Pop();
}
ch=getchar();
}
S.IsEmpty()?printf("Balanced\n"):printf("Not Balanced\n");
return 0;
}

int main()
{
printf("Enter string of braces:\n");
solve();
return 0;
}`

diegoba90 · 2020-07-12T22:02:46Z

I'm having a hard time with this. How can i make it so that instead of having the user input the string of characters it instead reads it from a file that has lines of different expressions.

rohitverma1999hack · 2020-09-25T06:46:06Z

return S.empty() ? true:false; is kind of redundant (if true return true else return false).
It's not redundant
what if the input is "(".

umamahesh33 · 2020-10-05T18:24:17Z

it will fail for the test case when we include the space in the user input because the taking of string input will not execute after a blank space

shoaibrain · 2020-10-09T14:50:07Z

`def balancedBrackets(string):
#remove all invalid characters. This is optional by the way.If your string only contains [{()}]. You don't have to change input string in any
way
string = [x for x in string if x in '[{()}]]']

stack = []

for char in string:
	if char in '([{':
		stack.append(char)
	else:
		if len(stack) == 0  or not arePair(stack[-1], char):
			return False
		else:
			stack.pop()
if len(stack) == 0:return True
return `False`

def arePair(opening,closing):
if opening == '(' and closing == ')':return True
elif opening == '[' and closing == ']': return True
elif opening == '{' and closing == '}':return True
return False
`

BaseMax · 2021-04-11T16:41:53Z

https://github.com/BaseMax/ValidationParentheses

ibrahimBanat · 2021-06-01T13:25:18Z

Solution Using JavaScript: you can also check the whiteboard and test from here:

class MultiBracketValidation {
  constructor() {
    this.stack = new Stack();
    this.opening = ["{", "(", "[", "<"];
    this.closing = ["}", ")", "]", ">"];
  }
  checkForValidation(input) {
    for (const char of input) {
      if (this.isOpening(char)) {
        this.stack.push(char);
      } else if (this.isClosing(char)) {
        if (
          this.stack.isEmpty() ||
          !this.isPair(this.stack.peek().value, char)
        ) {
          return false;
        } else {
          this.stack.pop();
        }
      }
    }
    return this.stack.isEmpty();
  }
  isOpening(char) {
    return this.opening.indexOf(char) >= 0;
  }
  isClosing(char) {
    return this.closing.indexOf(char) >= 0;
  }
  isPair(opening, closing) {
    return this.closing.indexOf(closing) === this.opening.indexOf(opening);
  }
}

HarshKakran · 2021-07-06T11:49:43Z

Hey, I am a beginner in programming, and tried to implement the pseudo code shared in the video using C++, can you guys share the reviews about the coding style.

bool checkBalancedParenthesis(string exp){
    stack<char> s;
    int n = exp.length();
    for(int i=0; i<n; i++){
        if (exp[i] == '{' || exp[i] == '(' || exp[i] == '['){
            s.push(exp[i]);
        }
        else if(exp[i] == '}' || exp[i] == ')' || exp[i] == ']'){
            if (s.empty())
            return false;
            switch (s.top())
            {
            case '(':
                if (exp[i] == ')')
                    {s.pop();
                    break;}
                else{
                    return false;
                }
            case '{':
                if (exp[i] == '}')
                    {s.pop();
                    break;}
                else{
                    return false;
                }
            case '[':
                if (exp[i] == ']')
                    {s.pop();
                    break;}
                else{
                    return false;
                }
            }
        }    
    }
    return s.empty()?true:false;
}

AshAman999 · 2021-07-23T17:56:44Z

Hey, I am a beginner in programming, and tried to implement the pseudo code shared in the video using C++, can you guys share the reviews about the coding style.

bool checkBalancedParenthesis(string exp){
    stack<char> s;
    int n = exp.length();
    for(int i=0; i<n; i++){
        if (exp[i] == '{' || exp[i] == '(' || exp[i] == '['){
            s.push(exp[i]);
        }
        else if(exp[i] == '}' || exp[i] == ')' || exp[i] == ']'){
            if (s.empty())
            return false;
            switch (s.top())
            {
            case '(':
                if (exp[i] == ')')
                    {s.pop();
                    break;}
                else{
                    return false;
                }
            case '{':
                if (exp[i] == '}')
                    {s.pop();
                    break;}
                else{
                    return false;
                }
            case '[':
                if (exp[i] == ']')
                    {s.pop();
                    break;}
                else{
                    return false;
                }
            }
        }    
    }
    return s.empty()?true:false;
}

If you are waiting for the mentors to reply then they ain't goint to reply and apart from that yeah coding style looks good

	/*
	C++ Program to check for balanced parentheses in an expression using stack.
	Given an expression as string comprising of opening and closing characters
	of parentheses - (), curly braces - {} and square brackets - [], we need to
	check whether symbols are balanced or not.
	*/
	#include<iostream>
	#include<stack>
	#include<string>
	using namespace std;
	// Function to check whether two characters are opening
	// and closing of same type.
	bool ArePair(char opening,char closing)
	{
	if(opening == '(' && closing == ')') return true;
	else if(opening == '{' && closing == '}') return true;
	else if(opening == '[' && closing == ']') return true;
	return false;
	}
	bool AreParanthesesBalanced(string exp)
	{
	stack<char> S;
	for(int i =0;i<exp.length();i++)
	{
	if(exp[i] == '(' \|\| exp[i] == '{' \|\| exp[i] == '[')
	S.push(exp[i]);
	else if(exp[i] == ')' \|\| exp[i] == '}' \|\| exp[i] == ']')
	{
	if(S.empty() \|\| !ArePair(S.top(),exp[i]))
	return false;
	else
	S.pop();
	}
	}
	return S.empty() ? true:false;
	}

	int main()
	{
	/Code to test the function AreParanthesesBalanced/
	string expression;
	cout<<"Enter an expression: "; // input expression from STDIN/Console
	cin>>expression;
	if(AreParanthesesBalanced(expression))
	cout<<"Balanced\n";
	else
	cout<<"Not Balanced\n";
	}

mycodeschool/BalancedParentheses.cpp

senthilnathan87 commented Aug 26, 2019 •

edited

Loading

misterpoloy commented Jan 10, 2020

asad2200 commented Apr 21, 2020 •

edited

Loading

hitsa70 commented Apr 29, 2020

FredLeg commented May 19, 2020 •

edited

Loading

siddharthmagadum16 commented Jun 9, 2020 •

edited

Loading

diegoba90 commented Jul 12, 2020

rohitverma1999hack commented Sep 25, 2020

umamahesh33 commented Oct 5, 2020

shoaibrain commented Oct 9, 2020 •

edited

Loading

BaseMax commented Apr 11, 2021

ibrahimBanat commented Jun 1, 2021

HarshKakran commented Jul 6, 2021

AshAman999 commented Jul 23, 2021

mycodeschool/BalancedParentheses.cpp

senthilnathan87 commented Aug 26, 2019 • edited Loading

misterpoloy commented Jan 10, 2020

asad2200 commented Apr 21, 2020 • edited Loading

hitsa70 commented Apr 29, 2020

FredLeg commented May 19, 2020 • edited Loading

siddharthmagadum16 commented Jun 9, 2020 • edited Loading

diegoba90 commented Jul 12, 2020

rohitverma1999hack commented Sep 25, 2020

umamahesh33 commented Oct 5, 2020

shoaibrain commented Oct 9, 2020 • edited Loading

BaseMax commented Apr 11, 2021

ibrahimBanat commented Jun 1, 2021

HarshKakran commented Jul 6, 2021

AshAman999 commented Jul 23, 2021

senthilnathan87 commented Aug 26, 2019 •

edited

Loading

asad2200 commented Apr 21, 2020 •

edited

Loading

FredLeg commented May 19, 2020 •

edited

Loading

siddharthmagadum16 commented Jun 9, 2020 •

edited

Loading

shoaibrain commented Oct 9, 2020 •

edited

Loading