Lenin Vladimir Escobar

test.java

// package whatever; // don't place package name!

// Write a function that returns true if the brackets in a given string are balanced. 
// Balanced means that every parenthesis/bracket or brace that is opened must be closed
// And it must be closed in the right order (Always close the last symbol you opened)
// The function must handle parens (), square brackets [], and curly braces {}.

import java.io.*;
import java.util.*;

class MyCode {
  /*Constants*/
  private static final char OPEN_PARENTHESIS = '(';
  private static final char CLOSE_PARENTHESIS = ')';
  
  private static final char OPEN_BRACE = '{';
  private static final char CLOSE_BRACE = '}';
  
  private static final char OPEN_BRACKET = '[';
  private static final char CLOSE_BRACKET = '[';
  
  public static void main (String[] args) {
    System.out.println("(a[0]+b[2c[6]])            passed:" + parensMatch("(a[0]+b[2c[6]])"));
    System.out.println("f(e(d))                    passed:" + parensMatch("f(e(d))"));
    System.out.println("[()]{}([])                 passed:" + parensMatch("[()]{}([])"));
    System.out.println("((b)                       passed:" + !parensMatch("((b)"));
    System.out.println("(c]                        passed:" + !parensMatch("(c]"));
    System.out.println("{(a[])                     passed:" + !parensMatch("{(a[])"));
    System.out.println("([)]                       passed:" + !parensMatch("([)]"));
    System.out.println("[({{}}])                   passed:" + !parensMatch("[({{}}])"));
    System.out.println(")(                         passed:" + !parensMatch(")("));
  }
  
  public static boolean parensMatch(String sentence){
    /*Implementation*/
    char[]sentenceArray = sentence.toCharArray();
    
    Stack<Character> stackParenthesis = new Stack<>();
    Stack<Character> stackBrace = new Stack<>();
    Stack<Character> stackBracket = new Stack<>();
    
    for(int indx = 0; indx < sentenceArray.length; indx ++){
      char currChar = sentenceArray[indx];
      
      if(currChar == OPEN_PARENTHESIS){
        stackParenthesis.push(currChar);
      }
      
      if(currChar == OPEN_BRACE){
        stackBrace.push(currChar);
      }
      
      if(currChar == OPEN_BRACKET){
        stackBracket.push(currChar);
      }
      
      if(currChar == CLOSE_PARENTHESIS){
        if(stackParenthesis.empty()){
          return false;
        }
        stackParenthesis.pop();
      }
      
      if(currChar == CLOSE_BRACE){
        if(stackBrace.empty()){
          return false;
        }
        stackBrace.pop();
      }
      
      if(currChar == CLOSE_BRACKET){
        if(stackBracket.empty()){
          return false;
        }
        stackBracket.pop();
      }
      
    }
    
    return stackParenthesis.empty() && stackBrace.empty() && stackBracket.empty();
    //return true;
  }
  
}