Java balanced expressions check

Question

I am trying to create a program that takes a string as an argument into its constructor  I need a method that checks whether the string is a balanced parenthesized expression  It needs to handle             each open needs to balance with its corresponding closing bracket  For example a user could input        which would be balanced and    would be unbalanced  This doesn t need to handle letters or numbers  I need to use a stack to do this   I was given this pseudocode but can not figure how to implement it in java  Any advice would be awesome    Update- sorry forgot to post what i had so far  Its all messed up because at first i was trying to use char and then i tried an array   im not exactly sure where to go    import java util     public class Expression     Scanner in   new Scanner System in     Stack lt Integer gt  stack   new Stack lt Integer gt          public boolean check           System out println  Please enter your expression         String newExp   in next        String   exp   new String newExp       for  int i   0  i  lt  size  i                   char ch   exp charAt i         if  ch           ch           ch                 stack push i         else if  ch          ch           ch                           nothing to match with         if stack isEmpty                          return false                    else if stack pop      ch                       return false                                            if  stack isEmpty                return true            else             return false

User · Answer

I call this brute force type approach we are replacing every () or {} or [] from the string with "" so therefore length of String is decreasing and if length of String doesn't change then i am simply breaking the loop otherwise if length of String gets down to 0 then it means everything in String is balanced otherwise not.

public class Question{
public static void main(String[] args) {
    String target="{ [ ( ) ] }",target2="( ) [ ] { }",target3="[ ( ) ] ( ( ) )",target4="( { [ )";
    target=target.replaceAll(" ","");
    target2=target2.replaceAll(" ", "");
    target3=target3.replaceAll(" ", "");
    target4=target4.replaceAll(" ", "");
    System.out.println(CheckExp(target));
    System.out.println(CheckExp(target2));
    System.out.println(CheckExp(target3));
    System.out.println(CheckExp(target4));
}
public static Boolean CheckExp(String target) {
    boolean flag = false;
    if (target.length() < 2 || target.length()%2!=0 ) {
        return flag;
    }
    int first,last;
    while(true) {
        first=target.length();
            target = target.replace("()", "");
            target = target.replace("{}","");
            target = target.replace("[]","");
            last=target.length();
            if(first==last)
                break;
            flag= target.length() == 0;
    }
    return flag;
}

}

User · Answer

Please try this I checked it  It works correctly  import java io BufferedReader  import java io IOException  import java io InputStreamReader  import java util HashMap  import java util Map  import java util Stack  public class CloseBrackets       private static Map lt Character  Character gt  leftChar   new HashMap lt  gt         private static Map lt Character  Character gt  rightChar   new HashMap lt  gt          static           leftChar put                    rightChar put                    leftChar put                    rightChar put                    leftChar put                    rightChar put                       public static void main String   args  throws IOException           BufferedReader bf   new BufferedReader new InputStreamReader System in            String st   bf readLine            System out println isBalanced st               public static boolean isBalanced String str             boolean result   false          if  str length    lt  2              return false          Stack lt Character gt  stack   new Stack lt  gt                For Example I gave input             str                                  for  int i   0  i  lt  str length    i                   char ch   str charAt i               if   rightChar containsKey ch   amp  amp   leftChar containsKey ch                     continue                               Left bracket only add to stack  Other wise it will goes to else case                 For both above input how value added in stack                      after close bracket go to else case             if  leftChar containsKey ch                     stack push ch                 else                   if   stack isEmpty                             For both input how it performs                        3rd character is close bracket so it will pop   pop value is     and map value for     key will       So both are same                           it will return true                          now stack will contain only       and travers to next up to end                      if  stack pop      rightChar get ch  charValue      stack isEmpty                              result   true                        else                           return false                                          else                       return false                                                     if   stack isEmpty                return result   false          return result

User · Answer

Using switch-case for better readability and handling of other scenarios   import java util Scanner  import java util Stack   public class JavaStack       private static final Scanner scanner   new Scanner System in        public static void main String   args                Scanner sc   new Scanner System in           while  sc hasNext                  String input   sc next                System out println isStringBalanced input                      scanner close                private static boolean isStringBalanced String testString                Stack lt Character gt  stack   new Stack lt Character gt             for  char c   testString toCharArray                  switch  c                    case                      case                      case                          stack push c                       break                  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                  default                      break                                     stack has to be empty  if not  the balance was wrong         return stack empty

User · Answer

import java util Objects  import java util Stack   public class BalanceBrackets        public static void main String   args            String input   a  d  b            System out println isBalance input                  private static boolean isBalance String input            Stack  lt Character gt  stackFixLength   new Stack             if input    null    input length    lt  2                throw  new IllegalArgumentException  in-valid arguments                       for  int i   0  i  lt  input length    i                   if  input charAt i            input charAt i            input charAt i                            stackFixLength push input charAt i                               if  input charAt i            input charAt i            input charAt i                             if stackFixLength empty    return false                   char b   stackFixLength pop                     if  input charAt i          amp  amp  b           input charAt i          amp  amp  b           input charAt i          amp  amp  b                               continue                    else                       return false                                                     return stackFixLength isEmpty

User · Answer

This is my implementation for this question  This program allows numbers  alphabets and special characters with input string but simply ignore them while processing the string   CODE   import java util Scanner  import java util Stack   public class StringCheck        public static void main String   args            boolean flag  false          Stack lt Character gt  input   new Stack lt Character gt             System out println  Enter your String to check             Scanner scanner   new Scanner System in           String sinput   scanner nextLine            char   c   new char 15           c   sinput toCharArray            for  int i   0  i  lt  c length  i                  if  c i            c i            c i                          input push c i                else if  c i                            if  input pop                                 flag   true                      continue                    else                       flag   false                      break                                  else if  c i                            if  input pop                                 flag   true                      continue                    else                       flag   false                      break                                  else if  c i                            if  input pop                                 flag   true                      continue                    else                       flag   false                      break                                                    if  flag    true              System out println  Valid String            else             System out println  Invalid String            scanner close

User · Answer

check Parenthesis public boolean isValid String s        Map lt Character  Character gt  map   new HashMap lt  gt         map put                map put                map put                Stack lt Character gt  stack   new Stack lt  gt         for char c   s toCharArray             if map containsKey c                stack push c             else if  stack empty    amp  amp  map get stack peek     c               stack pop              else               return false                      return stack empty

User · Answer

I hope this code can help   import java util Stack   public class BalancedParenthensies        public static void main String args               System out println balancedParenthensies    a b               System out println balancedParenthensies    a  b              System out println balancedParenthensies     a b                 public static boolean balancedParenthensies String s            Stack lt Character gt  stack    new Stack lt Character gt             for int i   0  i  lt  s length    i                  char c   s charAt i               if c           c           c                                 stack push c                 else if c                           if stack isEmpty      stack pop                                 return false                                  else if c                           if stack isEmpty      stack pop                                 return false                                             else if c                           if stack isEmpty      stack pop                                 return false                                                     return stack isEmpty

User · Answer

A slightly different approach I took to solve this problem  I have observed two key points in this problem   Open braces should be accompanied always with corresponding closed braces  Different Open braces are allowed together but not different closed braces   So I converted these points into easy-to-implement and understandable format   I represented different braces with different numbers Gave positive sign to open braces and negative sign for closed braces   For Example    quot             quot  will be  quot 1 -1 2 -2 3 -3 quot  is valid parenthesis  For a balanced parenthesis  positives can be adjacent where as a negative number should be of positive number in top of the stack  Below is code  import java util Stack   public class Main       public static void main  String    args                String value    quot              quot           System out println Main balancedParanthesis value                   public static boolean balancedParanthesis String s                                       char   charArray s toCharArray                     int   integerArray new int charArray length                                creating braces with equivalent numeric values         for int i 0 i lt charArray length i                               if charArray i                          integerArray i  1                            else if charArray i                          integerArray i  -1                            else if charArray i                          integerArray i  2                            else if charArray i                          integerArray i  -2                            else if charArray i                          integerArray i  3                            else                    integerArray i  -3                                           Stack lt Integer gt  stack new Stack lt Integer gt                      for int i 0 i lt charArray length i                               if stack isEmpty                      if integerArray i  lt 0                        stack push integerArray i                        break                                    stack push integerArray i                              else                  if integerArray i  gt 0                        stack push integerArray i                                      else                       if stack peek    - integerArray i                              stack pop                                              else                           break                                                                          return stack isEmpty

User · Answer

Please try this       import java util Stack       public class PatternMatcher           static String   patterns                                                          static String openItems                   boolean isOpen String sy                return openItems contains sy                      String getOpenSymbol String byCloseSymbol                switch  byCloseSymbol                case                      return                  case                      return                  case                      return                   default                  return null                                   boolean isValid String pattern                 if pattern    null                    return false                             Stack lt String gt  stack   new Stack lt String gt                 char   symbols   pattern toCharArray                 if  symbols length    0    symbols length   2    0                    return false                             for  char c   symbols                    String symbol   Character toString c                   if  isOpen symbol                         stack push symbol                     else                       String openSymbol   getOpenSymbol symbol                       if  stack isEmpty                                   openSymbol    null                                  openSymbol equals stack pop                               return false                                                                    return stack isEmpty                       public static void main String   args                PatternMatcher patternMatcher   new PatternMatcher                 for  String pattern   patterns                    boolean valid   patternMatcher isValid pattern                   System out println pattern     t    valid

User · Answer

An alternative to Hashmap and an efficient way would be to use a Deque   public boolean isValid String s         if s    null    s length      0          return true        Deque lt Character gt  stack   new ArrayDeque lt Character gt          for char c   s toCharArray                     if c                     stack addFirst                  else if c                     stack addFirst                   else if c                       stack  addFirst                    else if stack isEmpty      c    stack removeFirst                   return false                      return stack isEmpty

User · Answer

import java io IOException      import java util ArrayList      import java util List      import java util Scanner      import java util Stack      public class BalancedParenthesisWithStack          This is purely Java Stack based solutions without using additonal        data structure like array Map         public static void main String   args  throws IOException            Scanner sc   new Scanner System in              Take list of String inputs  parenthesis expressions both valid and           invalid from console            List lt String gt  inputs new ArrayList lt  gt             while  sc hasNext                   String input sc next                inputs add input                         For every input in above list display whether it is valid or             invalid parenthesis expression          for String input inputs              System out println   nisBalancedParenthesis   isBalancedParenthesis          input                           This method identifies whether expression is valid parenthesis or not      public static boolean isBalancedParenthesis String expression              sequence of opening parenthesis according to its precedence            i e      has higher precedence than     or             String openingParenthesis                   sequence of closing parenthesis according to its precedence         String closingParenthesis                   Stack will be pushed on opening parenthesis and popped on closing          Stack lt Character gt  parenthesisStack new Stack lt  gt                   For expression to be valid             CHECK             1  it must start with opening parenthesis                  2  precedence of parenthesis  should be proper  eg       invalid                                                                       valid                 3  matching pair if         gt        i e             - gt valid     not                        if closingParenthesis contains             Character expression charAt 0   toString                  return false           else          for int i 0 i lt expression length   i              char ch   Character expression charAt i              if parenthesis is opening ie any of              push on stack         if openingParenthesis contains ch toString                      parenthesisStack push ch                else if closingParenthesis contains ch toString                if parenthesis is closing  ie any of              pop stack           depending upon check-3                  if parenthesisStack peek         amp  amp   ch                               parenthesisStack peek         amp  amp   ch                                  parenthesisStack peek         amp  amp   ch                                                  parenthesisStack pop                                                       return  parenthesisStack isEmpty     true   false

User · Answer

This can be used  Passes all the tests   static String isBalanced String s         if null    s           return                Stack lt Character gt  bracketStack   new Stack lt  gt           int length   s length         if length  lt  2    length  gt  1000           return  NO               for int i   0  i  lt  length  i             Character c  s charAt i           if c           c           c                       bracketStack push c             else               if  bracketStack isEmpty                    char cPop   bracketStack pop                    if c         amp  amp  cPop                           return  NO                                    if c         amp  amp  cPop                           return  NO                                    if c         amp  amp  cPop                           return  NO                                  else                  return  NO                                       if bracketStack isEmpty             return  YES         else           return  NO

User · Answer

Here is the Code  I have tested all the possible test case on Hacker Rank   static String isBalanced String input         Stack lt Character gt  stack   new Stack lt Character gt         for  int i   0  i  lt  input length    i              Character ch   input charAt i           if  input charAt i            input charAt i                            input charAt i                        stack push input charAt i              else               if  stack isEmpty                            stack peek           amp  amp  ch                                 stack peek           amp  amp  ch                                 stack peek           amp  amp  ch                            return  NO                 else                   stack pop                                      if  stack empty            return  YES       return  NO

User · Answer

Late Post       package com prac stack   public class BalanceBrackets    public static void main String   args        String str                 char a     str toCharArray        System out println check a       static boolean check char   t        Stackk st   new Stackk        for  int i   0  i  lt  t length  i              if  t i            t i            t i                        st push t i                      if  t i            t i            t i                        if  st isEmpty                      return false                else if   isMatching st pop    t i                      return false                                     if  st isEmpty              return true        else           return false           static boolean isMatching char a  char b        if  a         amp  amp  b                   return true        else if  a         amp  amp  b                   return true        else if  a         amp  amp  b                   return true        else           return false

User · Answer

You are pushing i - the index - on the stack  and comparing against ch  You should push and pop ch

User · Answer

public static void main String   args        System out println  is balanced     isBalanced         lt  gt          System out println  is balanced     isBalanced         lt  gt          System out println  is balanced     isBalanced         lt  gt          System out println  is balanced     isBalanced      lt  gt             System out println  is balanced     isBalanced        lt  gt             System out println  is balanced     isBalanced          lt  gt           System out println  is balanced     isBalanced                 System out println  is balanced     isBalanced                 System out println  is balanced     isBalanced     lt   gt              System out println  is balanced     isBalanced            System out println  is balanced     isBalanced             System out println  is balanced     isBalanced  asdlsa        private static boolean isBalanced String brackets       char   bracketsArray   brackets toCharArray        Stack lt Character gt  stack   new Stack lt Character gt         Map lt Character  Character gt  openingClosingMap   initOpeningClosingMap         for  char bracket   bracketsArray            if openingClosingMap keySet   contains bracket                 stack push bracket            else if openingClosingMap values   contains bracket                if stack isEmpty      openingClosingMap get stack pop     bracket                   return false                         else              System out println  Only   lt   gt              brackets  are allowed                  return false                      return stack isEmpty       private static Map lt Character  Character gt  initOpeningClosingMap         Map lt Character  Character gt  openingClosingMap   new HashMap lt Character  Character gt         openingClosingMap put Character valueOf       Character valueOf            openingClosingMap put Character valueOf       Character valueOf            openingClosingMap put Character valueOf       Character valueOf            openingClosingMap put Character valueOf   lt     Character valueOf   gt          return openingClosingMap      Simplifying and making readable  Using One Map only and minimum conditions to get desired result

User · Answer

This is my own implementation  I tried to make it the shortest an clearest way possible   public static boolean isBraceBalanced String braces        Stack lt Character gt  stack   new Stack lt Character gt          for char c   braces toCharArray              if c           c           c                       stack push c             else if  c         amp  amp   stack isEmpty      stack pop                                  c         amp  amp   stack isEmpty      stack pop                                  c         amp  amp   stack isEmpty      stack pop                           return false                       return stack isEmpty

User · Answer

public class StackProb    public static void main String   args         Scanner sc   new Scanner System in       List lt Boolean gt  list   new ArrayList lt  gt          while  sc hasNextLine              String s sc nextLine            if  s isEmpty                  list add isBalanced s                  System out println isBalanced s             else               sc close                break                       for  int i   0  i  lt  list size    i              System out println list get i                    private static boolean isBalanced String s        boolean res   false      Stack lt Character gt  stack   new Stack        int countA   0      int countB   0      for  int i   0  i  lt  s length    i               if s charAt i          s charAt i          s charAt i                       stack push s charAt i                countA                        if s charAt i          s charAt i          s charAt i                       stack push s charAt i                countB                       if stack firstElement           stack firstElement           stack firstElement                       countB                          if countA  countB            return true            return false

User · Answer

How about this one  it uses both concept of stack plus counter checks    import java util    class Solution   public static void main String   argh       Scanner sc   new Scanner System in      while  sc hasNext            String input sc next          Stack lt Character gt  stk   new Stack lt Character gt           char   chr   input toCharArray          int ctrl   0  ctrr   0        if input length    0             System out println  true                  for int i 0  i lt input length    i               if chr i        chr i        chr i                       ctrl                  stk push chr i                    System out println stk                             for int i 0  i lt input length    i               if chr i        chr i        chr i                       ctrr                  if  stk isEmpty                      stk pop                    System out println stk                               System out println stk         if stk isEmpty   amp  amp ctrl  ctrr          System out println  true          else         System out println  false

User · Answer

balanced parentheses problem  By fabboys     include  lt iostream gt   include  lt string h gt   using namespace std   class Stack   char  arr  int size  int top   public   Stack int s      size   s    arr   new char size     top   -1     bool isEmpty       if top    -1      return true   else     return false       bool isFull        if top    size-1      return true   else     return false        void push char n      if isFull      false          top         arr top    n        char pop      if isEmpty      false          char x   arr top        top--       return x      else     return -1     char Top      if isEmpty      false         return arr top       else     return -1    Stack   delete   arr          int main     int size 0    string LineCode  cout lt  lt  Enter a String        cin  gt  gt  LineCode         size   LineCode length         Stack s1 size         char compare       for int i 0 i lt  size i            if LineCode i          LineCode i            LineCode i           s1 push LineCode i      else if LineCode i                if s1 isEmpty    false                       compare    s1 pop                    if compare    91                        else                                                   cout lt  lt   Error Founded                               return 0                         else                              cout lt  lt   Error Founded                  return 0                    else if LineCode i                  if s1 isEmpty      false                  compare   s1 pop             if compare    40             else              cout lt  lt   Error Founded                               return 0                   else                cout lt  lt  Error Founded                  return 0           else if LineCode i                    if s1 isEmpty      false                  compare   s1 pop             if compare    123             else              cout lt  lt   Error Founded                               return 0                   else                cout lt  lt   Error Founded                  return 0                 if s1 isEmpty    true        cout lt  lt  No Error in Program  n     else        cout lt  lt   Error Founded       return 0

User · Answer

Similar to one of the code above in JAVA but It needs one more else statement added in order to avoid stack comparison with characters other than braces    else if bracketPair containsValue strExpression charAt i     public boolean isBalanced String strExpression    Map lt Character Character gt  bracketPair   new HashMap lt Character Character gt       bracketPair put              bracketPair put              bracketPair put              Stack lt Character gt  stk   new Stack lt Character gt             for int i  0 i lt strExpression length   i                 if bracketPair containsKey strExpression charAt i                    stk push strExpression charAt i                else if bracketPair containsValue strExpression charAt i                     if stk isEmpty    bracketPair get stk pop     strExpression charAt i                   return false                     if stk isEmpty                return true              else                 return false

User · Answer

Code snippet for implementing matching parenthesis using java util Stack data structure -        map for storing matching parenthesis pairs     private static final Map lt Character  Character gt  matchingParenMap   new HashMap lt  gt            set for storing opening parenthesis     private static final Set lt Character gt  openingParenSet   new HashSet lt  gt          static            matchingParenMap put                    matchingParenMap put                     matchingParenMap put                     openingParenSet addAll matchingParenMap values                    check if parenthesis match     public static boolean hasMatchingParen String input          try              stack to store opening parenthesis          Stack lt Character gt  parenStack   new Stack lt  gt               for int i 0  i lt  input length    i                  char ch   input charAt i                  if an opening parenthesis then push to the stack             if openingParenSet contains ch                      parenStack push ch                                 for closing parenthesis             if matchingParenMap containsKey ch                      Character lastParen   parenStack pop                     if lastParen    matchingParenMap get ch                         return false                                                           returns true if the stack is empty else false          return parenStack isEmpty                      catch StackOverflowException s              catch StackUnderflowException s1              return false          I have explained the code snippet and the algorithm used on blog http   hetalrachh home blog 2019 12 25 stack-data-structure

User · Answer

Using node reference we can check easily  import java util ArrayList  import java util HashMap  import java util List  import java util Map     public class CloseBracketsBalance       private static final Map lt String  String gt  closeBracket  new HashMap lt  gt         private static final List lt String gt  allBrac   new ArrayList lt  gt          static           allBrac add               allBrac add               allBrac add               allBrac add               allBrac add               allBrac add               closeBracket put                    closeBracket put                    closeBracket put                       public static void main String   args            System out println checkSheetIsbalance            dsfd            return true         System out println checkSheetIsbalance            dsfd            return false            public static boolean checkSheetIsbalance String c            char   charArr   c toCharArray            Node node   null          for int i 0 j charArr length i lt j i                  String ch   charArr i                  if  allBrac contains ch                     continue                             if closeBracket containsKey ch                        node close bracket                                if node    null                        return false                                    if   node nodeElement  equals closeBracket get ch                          return false                                    node   node parent                 else                     make node for open bracket                                  node   new Node ch  node                                           if node    null                return false                     return true            class Node       public String nodeElement      public Node parent      public Node String el  Node p            this nodeElement   el          this parent   p

User · Answer

public static boolean isBalanced String expression      if   expression length     2     1  return false    else       Stack lt Character gt  s   new Stack lt  gt         for  char bracket   expression toCharArray          switch  bracket            case      s push       break          case      s push       break          case      s push       break          default             if  s isEmpty      bracket    s peek      return false             s pop                return s isEmpty           public static void main String   args        Scanner in   new Scanner System in       String expression   in nextLine        boolean answer   isBalanced expression       if  answer    System out println  YES         else   System out println  NO

User · Answer

static void checkBalanceParan String s   Stack lt Character gt stk new Stack lt  gt      int i 0  int size s length    while i lt size       if s charAt i        s charAt i        s charAt i                 stk push s charAt i            i              else if s charAt i       amp  amp  stk empty   amp  amp stk peek                      int x stk pop                i         else if s charAt i       amp  amp  stk empty   amp  amp stk peek                           int x stk pop            i                  else if s charAt i       amp  amp  stk empty   amp  amp stk peek                  int x stk pop            i          else      System out println  quot not Balanced quot            return                  System out println  quot Balanced quot

User · Answer

Considering string consists only of                          Here is a code method that returns true or false based on whether equation is balanced or not   private static boolean checkEquation String input         List lt Character gt  charList   new ArrayList lt Character gt          for  int i   0  i  lt  input length    i               if  input charAt i            input charAt i            input charAt i                        charList add input charAt i              else if   input charAt i          amp  amp  charList get charList size   - 1                              input charAt i          amp  amp  charList get charList size   - 1                              input charAt i          amp  amp  charList get charList size   - 1                         charList remove charList size   - 1             else             return false              if charList isEmpty            return true      else         return false

User · Answer

import java util Stack           public class StackParenthesisImplementation               public static void main String   args                    String Parenthesis                             char   charParenthesis    Parenthesis toCharArray                    boolean evalParanthesisValue   evalParanthesis charParenthesis                   if evalParanthesisValue    true                      System out println  Brackets are good                    else                     System out println  Brackets are not good                              static boolean evalParanthesis char   brackets                                       boolean IsBracesOk   false                  boolean PairCount   false                  Stack lt Character gt  stack   new Stack lt Character gt                     for char brace   brackets                                                               if brace           brace           brace                                  stack push brace                             PairCount   false                                            else if  stack isEmpty                                                  if brace           brace           brace                                                               char CharPop   stack pop                                if  brace         amp  amp  CharPop                                                                        IsBracesOk   true  PairCount   true                                                            else if  brace          amp  amp   CharPop                                                                        IsBracesOk   true  PairCount   true                                                            else if  brace          amp  amp   CharPop                                                                        IsBracesOk   true  PairCount   true                                                            else                                                                IsBracesOk   false                                  PairCount   false                                  break                                                                                                                        if PairCount    false                  return IsBracesOk   false                  else                     return IsBracesOk   true

User · Answer

public void validateExpression         if  str isEmpty    amp  amp  str    null           if   str trim   equals       amp  amp   str trim   equals                     char   chars   str toCharArray                 for char c  chars                   if  Character isLetterOrDigit c   amp  amp  c            c                               charList add c                                                for Character ele  charList                                      if operatorMap get ele     null  amp  amp  operatorMap get ele     0                                             operatorMap put ele operatorMap get ele  1                    else                      operatorMap put ele 1                                                for Map Entry lt Character  Integer gt  ele  operatorMap entrySet                     System out println String format  Brace Type    s   and count is    d      ele getKey   ele getValue                                                    if operatorMap get         operatorMap get                        System out println       Valid Expression                      else                  System out println       Invalid Expression                                 else              System out println       Incomplete expression to validate                         else          System out println       Expression is  empty or null

User · Answer

This code works for all cases include other chars not only parentheses ex  Please enter input     ibrahim k   true               true saddsd  false  public class Solution        private static Map lt Character  Character gt  parenthesesMapLeft   new HashMap lt  gt         private static Map lt Character  Character gt  parenthesesMapRight   new HashMap lt  gt          static           parenthesesMapLeft put                    parenthesesMapRight put                    parenthesesMapLeft put                    parenthesesMapRight put                    parenthesesMapLeft put                    parenthesesMapRight put                       public static void main String   args            System out println  Please enter input            Scanner scanner   new Scanner System in            String str   scanner nextLine             System out println isBalanced str               public static boolean isBalanced String str             boolean result   false          if  str length    lt  2              return false          Stack lt Character gt  stack   new Stack lt  gt             for  int i   0  i  lt  str length    i                   char ch   str charAt i               if   parenthesesMapRight containsKey ch   amp  amp   parenthesesMapLeft containsKey ch                     continue                            if  parenthesesMapLeft containsKey ch                     stack push ch                 else                   if   stack isEmpty    amp  amp  stack pop      parenthesesMapRight get ch  charValue                          result   true                    else                       return false                                                     if   stack isEmpty                return result   false          return result

User · Answer

The improved method  from  Smartoop   public boolean balancedParenthensies String str        List lt Character gt  leftKeys   Arrays asList             lt              List lt Character gt  rightKeys   Arrays asList             gt               Stack lt Character gt  stack   new Stack lt  gt         for  int i   0  i  lt  str length    i              char c   str charAt i           if  leftKeys contains c                 stack push c             else if  rightKeys contains c                 int index   rightKeys indexOf c               if  stack isEmpty      stack pop      leftKeys get index                     return false                                    return stack isEmpty

User · Answer

It s important to use a stack to push opening symbols onto it  then when you come across a closing brace you pop the element off the top of the stack and then you check it to see if it matches the type of closing brace  Here is a java implementation   import java util Stack   public class Balanced       public static void main  String    args                String test good                           String test bad                           System out println checkBalanced test good            System out println checkBalanced test bad               public static boolean checkBalanced String check                Stack lt Character gt  S   new Stack lt Character gt             for int a   0  a  lt  check length    a                          char let   check charAt a               if let           let           let                         S push let               else if let           let           let                                       if S empty                        return false                  switch let                                           Opening square brace                     case                              if  S pop                                       return false                          break                         Opening curly brace                     case                              if  S pop                                       return false                          break                         Opening paren brace                     case                              if  S pop                                       return false                          break                      default                          break                                                    if S empty                return true          return false

User · Answer

Do you mind  if I will add my freaky-style solution based on JavaScript   It s an ad-hoc stuff  not for production  but for the interviews or something like that  Or just for fun   The code   function reduceStr  str      const newStr   str replace           replace           replace             if  newStr     str  return reduceStr newStr    return newStr    function verifyNesting  str      return reduceStr str  length     0     Checks   console log verifyNesting                                correct console log verifyNesting                                incorrect   Explanation   It will recursively remove closes pairs            and                                                                                                        If at the end string s length will be empty - it s true  if not - it s false   P S  Few answers   Why not for production    Because it s slow  and don t care about the possibility of some other characters between pairs    Why JS  We love Java   Because I m a frontend developer but met the same task  so perhaps it can be useful for somebody  And JS is also JVM lang      But why      Because all JS developers are crazy  that s why

User · Answer

package Stack   import java util Stack   public class BalancingParenthesis     boolean isBalanced String s         Stack lt Character gt  stack   new Stack lt Character gt          for  int i   0  i  lt  s length    i               if  s charAt i            s charAt i            s charAt i                         stack push s charAt i       push to the stack                     if  s charAt i            s charAt i            s charAt i                         if  stack isEmpty                      return false     return false as there is nothing to match                            Character top   stack pop       to get the top element in the stack              if  top         amp  amp  s charAt i            top         amp  amp  s charAt i                                top         amp  amp  s charAt i                             return false                                       if  stack isEmpty              return true     check if every symbol is matched            return false     if some symbols were unmatched    public static void main String   args         BalancingParenthesis obj   new BalancingParenthesis         System out println obj isBalanced                           Time Complexity   O n

User · Answer

The pseudo code equivalent java implementation of the algorithm is java is as follows     import java util HashMap  import java util Map  import java util Stack           author Yogen Rai      public class BalancedBraces       public static void main String   args            System out println isBalanced            YES     NO       YES         System out println isBalanced            YES     NO       NO          System out println isBalanced            YES     NO       YES          System out println isBalanced             YES     NO       NO            public static boolean isBalanced String brackets               set matching pairs         Map lt Character  Character gt  braces   new HashMap lt  gt             braces put                    braces put                   braces put                       if length of string is odd  then it is not balanced         if  brackets length     2    0                return false                        travel half until openings are found and compare with            remaining if the closings matches         Stack lt Character gt  halfBraces   new Stack            for char ch  brackets toCharArray                  if  braces containsKey ch                     halfBraces push braces get ch                                 if stack is empty or if closing bracket is not equal to top of stack                 then braces are not balanced             else if halfBraces isEmpty      ch    halfBraces pop                      return false                                  return halfBraces isEmpty

[java] Java balanced expressions check {[()]}

Examples related to java

Examples related to stack

Examples related to pseudocode