Question

Pascal programming language

Implement a symbol balance checker function for the Pascal programming language. Pascal allows for the following pairs: {}, (), [], begin end . All programs will begin with the word "begin" and end with the word "end". Your function should receive an ifstream object which is already open and will return true, all of the symbols match, or false, they do not. You do not have to worry about comments in the program but you do have to avoid other parts of the program's code such as assignment statements (x=y) and other expressions.

For example, Input ' ({}[])() ' is balanced

while ' (({]' is not

Answer 1

//using linked list

#include<stdio.h>
#include<stdlib.h>
struct link{
    char data;
    struct link *next;
};
int c=0;
struct link *head=NULL;
void push(char ele)
{
struct link *curr,*temp;
curr=(struct link *)malloc(sizeof(struct link));
curr->data=ele;
curr->next=NULL;
c++;
if(head==NULL)
head=curr;
else
{
   temp=head;
   while(temp->next!=NULL)
   {
        temp=temp->next;
   }
       temp->next=curr;
}
}
void pop()
{
    struct link *temp,*curr;
    if(head==NULL)
       printf("no elements to delete\n");
   else
   {
    temp=head;
    while(temp->next!=NULL)
    {
        curr=temp;
        temp=temp->next;
    }
    curr->next=NULL;
    c--;
}

}
char peep()
{
   struct link *temp;
   temp=head;
   if(temp==NULL)
      return 'p';
   else
   {
  
   while(temp->next!=NULL)
      temp=temp->next;
      return temp->data;
   }
}
main()
{
    char str[100];
    printf("enter expression\n");
    scanf("%s",str);
    int i=0;
   // printf("%s\n",str);
    while(str[i]!='\0')
    {
       if(str[i]=='('||str[i]=='{'||str[i]=='[')
           push(str[i]);
        else if(str[i]==')')
        {
           if(peep()=='(')
              pop();
           else
           {
          
               printf("wrong statement\n");
               exit(0);
           }
        }
        else if(str[i]==']')
        {
           if(peep()=='[')
              pop();
           else
           {
              
               printf("wrong statement\n");
               exit(0);
              }
        }
         else if(str[i]=='}')
        {
           if(peep()=='{')
              pop();
           else
           {
              
               printf("wrong statement\n");
               exit(0);
           }
        }
       i++;  
                             
    }
         // printf("%c\n",str[i]);
          //printf("%d\n",c);
          if(c==0&&str[i]!='}'&&str[i]!=')'&&str[i]!=']')
            printf("correct\n");
          else
             printf("incorrect\n");
                    

  
}

// here I used linked list but we can slove this by stack

// Java program for checking
// balanced Parenthesis

public class BalancedParan
{
   static class stack
   {
       int top=-1;
       char items[] = new char[100];

       void push(char x)
       {
           if (top == 99)
           {
               System.out.println("Stack full");
           }
           else
           {
               items[++top] = x;
           }
       }

       char pop()
       {
           if (top == -1)
           {
               System.out.println("Underflow error");
               return '\0';
           }
           else
           {
               char element = items[top];
               top--;
               return element;
           }
       }

       boolean isEmpty()
       {
           return (top == -1) ? true : false;
       }
   }
  
   /* Returns true if character1 and character2
   are matching left and right Parenthesis */
   static boolean isMatchingPair(char character1, char character2)
   {
   if (character1 == '(' && character2 == ')')
       return true;
   else if (character1 == '{' && character2 == '}')
       return true;
   else if (character1 == '[' && character2 == ']')
       return true;
   else
       return false;
   }
  
   /* Return true if expression has balanced
   Parenthesis */
   static boolean areParenthesisBalanced(char exp[])
   {
   /* Declare an empty character stack */
   stack st=new stack();
  
   /* Traverse the given expression to
       check matching parenthesis */
   for(int i=0;i<exp.length;i++)
   {
          
       /*If the exp[i] is a starting
           parenthesis then push it*/
       if (exp[i] == '{' || exp[i] == '(' || exp[i] == '[')
           st.push(exp[i]);
  
       /* If exp[i] is an ending parenthesis
           then pop from stack and check if the
           popped parenthesis is a matching pair*/
       if (exp[i] == '}' || exp[i] == ')' || exp[i] == ']')
       {
              
           /* If we see an ending parenthesis without
               a pair then return false*/
           if (st.isEmpty())
           {
               return false;
           }
  
           /* Pop the top element from stack, if
               it is not a pair parenthesis of character
               then there is a mismatch. This happens for
               expressions like {(}) */
           else if ( !isMatchingPair(st.pop(), exp[i]) )
           {
               return false;
           }
       }
          
   }
      
   /* If there is something left in expression
       then there is a starting parenthesis without
       a closing parenthesis */
      
   if (st.isEmpty())
       return true; /*balanced*/
   else
       { /*not balanced*/
           return false;
       }
   }
  
   /* UTILITY FUNCTIONS */
   /*driver program to test above functions*/
   public static void main(String[] args)
   {
       char exp[] = {'{','(',')','}','[',']'};
       if (areParenthesisBalanced(exp))
           System.out.println("Balanced ");
       else
           System.out.println("Not Balanced ");
   }

}