Encode && Decode

Here I am uploading some of the C programming codes, i have faced in my college days. If anyone is helped with my effort, i will consider myself very lucky........

Prob 1:) Write a C programme to evaluate the power set of a given set

include stdio.h 
include stdlib.h 
include string.h
int cnt=1;
char exp[10][10];
int n;
//char exp[11][10];
void dec_bin(int x);
int main()
{
    //char exp[100];
    int i,row=1,j,k,x;
    printf("\n\t");
    printf("\n...Enter The Number of elements of the Set ->.....->>>>>");
    //gets(exp);
    scanf("%d",&n);
        //len=strlen(exp);
            for(x=0;x lt n;x++)
            {
                    scanf("%s",&exp[x]);
            }
            for(i=0;i lt x;i++)
           {
                row=row*2;
            }
        //printf("Line No is=%d",row);
        printf("\n");

/*------------Starting The Power Set Evaluation--------------------------*/

            printf("\n.....The Power Set is......\n");
                    for(j=0;j lt row;j++)
                    {
                          dec_bin(j);
                    }
printf("\n");

return 0;
}
void dec_bin(int x)
{
        int count,temp,c,p=0;
        char num[1000];
        for(count=0;count lt n;count++)
     {
                temp=(x%2);
                num[count]=temp;
                x=(x/2);
        }
        //printf("\NNNNNNNN====%d",n);
        printf("<%d>==[",cnt++);
        for(c=0;c lt n;c++)\
     {
                if(num[c]==1)
                {
                    if(c==n)
                    {
                      printf(" %s ",exp[c]);
                      p==1;
                    }
                    else
                    {
                      printf(" %s ",exp[c]);
                      p==1;
                    }
                }
            }
            printf("]\n");
}






Prob 2:)Menu driven choice to implement Priority Queue


include stdio.h
include stdlib.h

void insertion();
void deletion();
void display();
struct dll
{
      int data;
      struct dll *left;
      struct dll *right;
};
struct dll *front=NULL;
int main()
{
    int option;
    while(!0)
    {
        printf("\n----------Enlist The Options--------------\n");
        printf("\n\tPress 1 for insert an item");
        printf("\n\tPress 2 for delete from Priority queue");
        printf("\n\tPress 3 for List the output");
        printf("\n\tPress 4 for exit");
        printf("\n\tPress the key as per choice=");
        scanf("%d",&option);
        switch(option)
        {
             case 1:
                     insertion();
                     break;
             case 2:
                     deletion();
                     break;
             case 3:
                     display();
                     break;
             case 4:
                     exit(1);
             default:
                     printf("\nRe Enter Once More Please\n");
                     break;
        }
    }
getch();
return 0;
}
void insertion()
{
  struct dll *p;
  int item;
  p=(struct dll *)malloc(sizeof(struct dll));
  if(p==NULL)
  {
      printf("\n Not Enough Space To Create Node");
      exit(1);
  }
  printf("\n\tEnter The item to be inserted=");
  scanf("%d",&item);
  p->data=item;
  if(front==NULL)
  {
      p->right=NULL;
      front=p;
  }
  else
  {
        struct dll *q;
        q=front;
            while(q->right!=NULL)
            {
                  q=q->right;

            }
            q->right=p;
            p->right=NULL;
            p->left=q;
  }
}
void deletion()
{
  struct dll *p;
  int min;
  p=(struct dll *)malloc(sizeof(struct dll));
  if(p==NULL)
  {
      printf("\n Not Enough Space To Create Node");
      exit(1);
  }
  if(front==NULL)
  {
      printf("\n---------------Nothing To Delete----------------\n\n");
  }
  else
  {
        struct dll *temp,*prv,*next;
        p=front;
        min=p->data;
            while(p->right!=NULL)
            {
                p=p->right;
                if(p->data<=min)
                {
                    min=p->data;
                }
            }
            printf("\n~~~~~~~~~~~~The Deleted Item is %d~~~~~~~~~~~~~~~~~~~~",min);
            temp=front;
                 while(temp!=NULL)
                 {
                      temp=temp->right;
                      if(temp!=NULL)
                      {
                        if(min==temp->data)
                        {
                            if(temp->right==NULL)
                            {
                                prv=temp->left;
                                prv->right=NULL;
                                free(temp);
                            }
                            else
                            {
                                prv=temp->left;
                                next=temp->right;
                                next->left=prv;
                                prv->right=next;
                                free(temp);
                            }
                         break;
                        }
                      }
                      else if(min==front->data)
                      {
                         front=front->right;
                         break;
                      }
                 }
  }
}
void display()
{
  struct dll *trav,*shift;
  int swap;
  trav=front;
  if(trav==NULL)
  {
      printf("\n\tTHE DOUBLE LINK LIST IS");
      printf("\n--------------------------------------------");
      printf("\n\n");
      printf("\n---------------------------------------------");
  }
  else
  {
      printf("\n\tTHE DOUBLE LINK LIST IS");
      printf("\n--------------------------------------------");
      printf("\n");
      while(trav!=NULL)
      {
            shift=trav->right;
            while(shift!=NULL)
            {
                 if(trav->data>=shift->data)
                 {
                     swap=trav->data;
                     trav->data=shift->data;
                     shift->data=swap;
                 }
              shift=shift->right;
            }
            printf("\t%d",trav->data);
            trav=trav->right;
      }
      printf("\n");
      printf("\n---------------------------------------------");
  }
}

Prob 3:) Programme to find the kth Smallest element from a list using median

#include stdio.h
#include conio.h
#include stdlib.h
#include string.h
#include time.h
void recurse(int ub, int lb);
void insertion(int arr[], int x);
int final_median();
void partition(int x[], int c, int d, int f);
int find_index(int m[], int b, int j);
int *arr,*splt;
int kth_element,k;
int *median,med;
int count=0;
int main()
{
    srand(time(0));
    int i,no;
    printf("\n\t...Enter No Of Elements....=");
    scanf("%d",&no);
    arr=(int *)calloc(no,sizeof(int));
    for(i=0;i lt no;i++)
    {
        arr[i]=rand()%no;
    }
    printf("\n\n\tTHE RANDOM INPUT IS........\n\n");
    for(i=0;i lt no;i++)
    {
        printf(" %d ",arr[i]);
    }
    printf("\n\n\t...ENTER THE kth Smallest Element(k    scanf("%d",&kth_element);
    med=0;
    recurse(no-1,0);
    if(count==0)
    {
       printf("\n...DESIRED ELEMENT NOT FOUND.....\n");
    }
getch();
return 0;
}
void recurse(int ub, int lb)
{
   int i,j,init,s,par,total,m,up_bnd,dn_bnd;
   up_bnd=ub;
   dn_bnd=lb;
   total=(up_bnd-dn_bnd+1);
   init=lb;
   if(ub gt lb)
   {
    for(i=total;i gt =1;i--)
    {
       if(total%i==0)
       {
          par=i;
          break;
       }
    }
    median=(int *)malloc(par*sizeof(int));
    splt=(int *)malloc((total/par)*sizeof(int));
    k=0;
    for(i=0;i    {
        for(j=init;j lt (init+(total/par));j++)
        {
            splt[k++]=arr[j];
        }
        init=j;
        /*---------Showing The splliting arrays---------*/
        /*printf("\n\n.........THE %d th SPLITTED ARRAY IS........",i+1);
        for(s=0;s lt k;s++)
        {
           printf(" %d ",splt[s]);
        }*/
        if(k>0)
        insertion(splt,k);
        k=0;
    }   
   /*printf("\n\n....THE LIST OF MEDIANS ARE.......\n\n");
   for(i=0;i lt med;i++)
   {
      printf("\t%d",median[i]);
   }*/
    printf("\n\n");
    if(med gt 0)
    {
     m=final_median();
     med=0;
     //printf("\n\n\t....THE ULTIMATE MEDIAN IS........=%d",m);
     partition(arr,m,dn_bnd,up_bnd);
    }
    /*else
    {
        exit(1);
    }*/
  }
}
void insertion(int arr[], int x)
{
     int i,j,temp;
     for(i=0;i< le x;i++)
     {
        temp=arr[i];
        for(j=i;j gt 0;j--)
        {
            if(arr[j-1] gt temp)
            {
                arr[j]=arr[j-1];
                arr[j-1]=temp;
            }
            else
            {
                break;
            }
        }
     }
     /*printf("\n\tTHE sorted array is\n\n");
     for(i=0;i     {
        printf(" %d ",arr[i]);
     }*/
     /*---------------FINDING THE MEDIAN FROM SORTED ARRAY----------------*/
     if(x%2==0)
     {
        temp=(x/2)+1;
     }
     else if(x%2!=0)
     {
         temp=(x+1)/2;
     }
     median[med++]=arr[temp-1];
}
int final_median()
{
     int i,j,key,index;
     int fn_med;
     for(i=0;i lt med;i++)
     {
         key=median[i];
         for(j=i;j gt 0;j--)
         {
            if(median[j-1] gt key)
            {
                median[j]=median[j-1];
                median[j-1]=key;
            }
            else
            {
                break;
            }
        }
     }
     /*printf("\n\n....THE SORTED FINAL MEDIAN ARRAY IS......\n\n");
     for(int f=0;f     {
         printf(" %d ",median[f]);
     }*/
     if(med%2!=0)
     {
        index=(med+1)/2;
     }
     else
     {
         index=(med/2)+1;
     }
     //printf("\n...INDEX=%d",index);
     fn_med=median[index-1];
return(fn_med);
}
void partition(int x[], int m, int lb, int ub)
{
     int up,down,pivot,swap,ind,high,low,calc;
     int total;
     pivot=m;
     up=ub;
     down=lb;
     if(ub gt lb)
     {
      while(up gt down)
      {
          while(x[down] le pivot && down lt up)
          {
               down++;
          }
          while(x[up] gt pivot)
          {
               up--;
          }
          if(up gt down)
          {
               swap=x[down];
               x[down]=x[up];
               x[up]=swap;
          }
      }
      calc=ub-lb+1;
      total=calc;
      if(total>0)
      {
       ind=find_index(x,calc,pivot);
       swap=x[down-1];
       x[down-1]=pivot;
       x[ind]=swap;
      }
       calc=down-1;
       printf("\n....The Index of Pivot is...=%d",calc+1);
      //printf("\nCOUNT IS=%d----------------%d-------------%d",count,ub,lb);
      //printf("\n\n....THE PARTITION IS......\n\n");
      /*for(int i=0;i lt total;i++)
      {
         printf(" %d ",x[i]);
      }*/
      if(kth_element==(calc))
      {
         printf("\n\n------------------------------");
         printf("\n\t\t..THE %d th SMALLEST ELEMENTS IS %d",kth_element,x[calc]);
         printf("\n--------------------------------\n\n");
         count++;
      }
      else if(kth_element lt (calc))
      {
        //kth_element=(calc-kth_element);
        high=calc-1;
        low=lb;
        //if(low        recurse(high,low);
        /*else
        {
            printf("\n\n...NOT FOUND.....");
            exit(1);
        }*/
      }
      else
      {
         //kth_element=(calc+kth_element);
         high=ub;
         low=calc+1;
         //if(low lt high)
         recurse(high,low);
         /*else
         {
             printf("\n\n....NOT FOUND....");
             exit(1);
         }*/
      }
     }
     /*else
     {
         printf("\n\n...NOT FOUND.....\n\n");
     }*/
}
int find_index(int m[], int bound, int y)
{
    int i,ret;
    for(i=bound-1;i gt 0;i--)
    {
        if(m[i]==y)
        {
           return i;
        }
    }
} 


Prog 4:) Programme to sort data using Radix Sorting method 

 #include
#include
#include
#include
void arr_copy(int i);
void count_sort(int a[],int y);
void show(int a, int b);
void pos_shift(int f[], int r);
int **inp,no,k;
void arr_copy(int l)
{
     int *temp;
     int i,j,bound,x;
     bound=0;
     x=1;
     temp=(int *)malloc(no*sizeof(int));
     while(bound lt k)
     {
        j=l-bound-1;
        for(i=0;i lt no;i++)
        {
           temp[x]=inp[i][j];
           x++;
        }
        count_sort(temp,bound);
        x=1;
        bound++;
     }
}
void count_sort(int temp[],int bound)
{
    int *freq,*sort,i,j,var,temp1,temp2;
    freq=(int *)calloc(no,sizeof(int));
    sort=(int *)malloc(no*sizeof(int));
    for(i=1;i le no;i++)
    {
       var=temp[i];
       freq[var]=freq[var]+1;
    }
    for(i=1;i le no;i++)
    {
        var=freq[i-1];
        freq[i]=freq[i]+var;
    }
    for(i=no;i ge 1;i--)
    {
         temp1=temp[i];
         temp2=freq[temp1];
         freq[temp1]=freq[temp1]-1;
         sort[temp2]=temp[i];
    }
    pos_shift(sort,bound);
}
void pos_shift(int temp[], int bound)
{
     int **x,i,j,index,temp_row,k1,init=0;
     x=(int **)malloc(no*sizeof(int *));
     for(i=0;i lt no;i++)
     {
        x[i]=(int *)malloc(k*sizeof(int));
     }
     j=k-bound-1;
     for(index=1;index le no;index++)
     {
         for(i=0;i lt no;i++)
         {
            if(temp[index]==inp[i][j])
            {
               for(k1=0;k1 lt k;k1++)
               {
                  x[init][k1]=inp[i][k1];
               }  
               init++;
               inp[i][j]=-1;
               break;
            }
          }
      }
     /*--------------copy the value of temporary to original----------------*/
     for(i=0;i     {
         for(j=0;j lt k;j++)
         {
             inp[i][j]=x[i][j];
         }
     }
}
void show(int i, int x)
{
     int s;
     printf("\n\n");
     for(s=0;s lt x;s++)
     {
        printf("\t%d ",inp[i][s]);
     }
}
int main()
{
    srand(time(0));
    int i,j,status=0;
    printf("\n\t...NO OF ELEMENTS TO BE SORTED...=");
    scanf("%d",&no);
    printf("\n\t..DIGIT OF EACH ELEMENT..=");
    scanf("%d",&k);
    if(no%2==0)
    {
       status=1;
       no=no+1;
       inp=(int **)malloc(no*sizeof(int *));
       for(i=0;i lt no;i++)
       {
         inp[i]=(int *)malloc(k*sizeof(int));
         printf("\n");
         for(j=0;j lt k;j++)
         {
            if(i==no-1)
            {
               inp[i][j]=rand()%(1);
            }
            else
            {
               if(no gt 9)
               {
                  inp[i][j]=rand()%9;
               }
               else
               {
                 inp[i][j]=rand()%(no);
               }
            }
         }
         if(i!=no-1)
         {
            show(i,k);
         }
       }
    }
    else
    {
       inp=(int **)malloc(no*sizeof(int *));
       for(i=0;i lt no;i++)
       {
         inp[i]=(int *)malloc(k*sizeof(int));
         printf("\n");
         for(j=0;j lt k;j++)
         {
            if(no>9)
            {
               inp[i][j]=rand()%9;
            }
            else
            {
               inp[i][j]=rand()%(no);
            }
         }
         show(i,k);
       }
    }
    if(no ge 2)
    {
        arr_copy(k);
    }
    printf("\n\n\n\t\t-------SORTED OUTPUT IS--------\n\n");
    for(i=status;i lt no;i++)
    {
        printf("\n");
        show(i,k);
    }
    printf("\n\n");
getch();
return 0;
}   

Prog5:) Programme to place 8 Queens' in a 8 * 8 chessboard such that no two queen attack each other

/*N QUEEN SOLUTION USING METHOD OF BACKTRACKING*/

#include stdio.h
#include conio.h
#include stdlib.h
#include string.h

/*#define queen 8*/

int clash_queen(int m,int n);
void place_board(int x);
void display();
void push(struct stack **t, int ele);
int pop(struct stack **t);

char **board;
int qn=0,once=0,queen;

struct stack
{
    int data;
    struct stack *ptr;
};

struct stack *front=NULL;
struct stack *root=NULL;

void push(struct stack **front,int val)
{
     struct stack *temp;
     temp=(struct stack *)malloc(sizeof(struct stack));
     temp->data=val;
     temp->ptr=NULL;
     if((*front)==NULL)
     {
         *front=temp;
          root=*front;
     }
     else
     {
          (*front)->ptr=temp;
          (*front)=temp;
     }
}

int pop(struct stack **front)
{
     int copy;
     if((*front)==NULL)
     {
        if(once==0)
        {
            printf("\n.....NO SOLUTION OF %d QUEEN PROBLEM IS AVAILABLE",queen);
        }
        else
        {
            printf("\n.....NO MORE SOLUTION OF %d QUEEN PROBLEM IS AVAILABLE",queen);
        }
      exit(1);
     }
     else
     {
         struct stack *q,*p;
         q=root;
         if(q->ptr==NULL)
         {
             copy=(*front)->data;
             *front=NULL;
                  free(q);
             return(copy);
         }
         else
         {
             while(q->ptr!=NULL)
             {
                 p=q;
                 q=q->ptr;
             }
             p->ptr=NULL;
             *front=p;
             copy=q->data;
             free(q);
             return(copy);
         }
     }
}

int clash_queen(int m,int n)
{
    int temp_row,temp_col,i,j;
    temp_row=m;
    temp_col=n;

           /*---Vertically Upwards Check-----*/

        for(i=temp_row,j=temp_col;i gt=0;i--)
        {
            if(board[i][j]=='*')
            {
                return 0;
            }
        }

        /*----Vertically Left Corner wise Check------*/

        for(i=temp_row,j=temp_col;i gt=0 && j gt=0;i--,j--)
        {
            if(board[i][j]=='*')
            {
              return 0;
            }
        }

        /*----Vertically Right Corner wise Check------*/      

        for(i=temp_row,j=temp_col;i gt=0 && j gt=0;i--,j++)
        {
            if(board[i][j]=='*')
            {
              return 0;
            }
        }

return 1;

}

int main()
{
    int i,j,row;
    printf("\n\t----CHOOSE THE SIZE OF BOARD AS UR WISH!---=");
    scanf("%d",&queen);
      board=(char **)malloc(queen*sizeof(char *));
    for(i=0;i lt queen;i++)
    {
           board[i]=(char *)calloc(queen,sizeof(char));
    }
    row=0;
    place_board(row);

getch();
return 0;

}

void place_board(int x)
{
    int i=x,j,flag=0,temp,cl=0,next;
    char choice;

    printf("\n\t-----------The %d Queen Solution is-------------\n\n",queen);

    while(i    {
        for(j=cl;j lt queen;j++)
        {

            /*---If a vacant position is found---*/

            if(clash_queen(i,j)==1)
            {
                 push(&front,j);
                 board[i][j]='*';
                 i++;
                 flag=1;          
                 break;
             }
        }

        /*------Queen not placed in an entire row---*/

        if(flag==0)/*BACKTRACKING IS DONE*/
        {
            temp=pop(&front);
            board[i-1][temp]=0;/*---Backtrack to the previous row and Queen is removed-----*/
            cl=temp+1;
            i--;
        }

        /*------Queen is placed in a collumn and start check from next row-------*/

        else if(flag==1 && i!=queen)
        {
            flag=0;
            cl=0;
        }
        else if(i==queen)
        {
            display();
            printf("\nPress 1 for more solution any other to stop");
            printf("\nDo U Want Any More Solution:=");
            scanf("%d",&choice);
            if(choice!=1)
            exit(1);

            /*------One solution is done..Go for next solution------*/

            else
            {
                 next=pop(&front);
                 board[i-1][next]=0;
                 cl=next+1;
                i--;
                flag=0;
              }
        }

      }
}

void display()
{
      int soln[50],k=0,temp;
      int col,i,j,var=0,p;
      once++;
      while(front!=NULL)
      {
          col=pop(&front);
          soln[k]=col;
          k++;
      }
          printf("\n\t\t-----The %d th Solution is------",++qn);
          for(i=k-1;i gt =0;i--)
          {
              push(&front,soln[i]);//Stack is filled by the old solution value.
              if(var!=0)
              printf("\n\t\t-------------------------------");
              printf("\n\n\t\tRow No is=%d AND Collumn No is=%d",var+1,soln[i]+1);
              var++;
          }
          printf("\n\t\t-------------------------------");

          printf("\n\n\n\t\t*********The Positions in The Board Are**************\n");

     i=0;

     printf("\n\n\n\n");

     while(i     {
            temp=soln[queen-i-1];
            printf("\t");
            for(j=0;j lt (queen*8)+1;j++)
            {
                 printf("-");
            }
            printf("\n");
            for(p=0;p lt =4;p++)
            {
                printf("\t");
                 for(j=0;j lt (queen*8)+1;j++)
                 {
                      if(j%8==0)
                      {
                          printf("|");
                      }
                      else if(p==2 && j==((2*temp)+1)*4)
                      {
                             printf("Q");
                      }
                      else
                      {
                            printf(" ");
                      }
                 }
                 printf("\n");
          }
     i++;
     }

     printf("\t");

     for(j=0;j lt (queen*8)+1;j++)
     {
            printf("-");
     }
} 
Prog 6:) Code to find whether a relation is equivalence relation or not?

#include stdio.h
#include stdlib.h
#include string.h
int sym_ch(char u,char v);
int part_one(char u,char v);
int part_two(char p,char q);
char exp[100];
char set[10];
char dis_opr[10];
int len,false=0;
int main()
{
    int len1,ret=0,r,n,dis;
        printf("\n...Set Element must be distinct....\n");
        printf("\n...Input the set....-:-");
        gets(set);
        printf("\n");
        len1=strlen(set);
                printf("\n...Distinguishing Between two ordered pair by (,) operator.....\n");
                printf("\n...Input The Relation from the User in ordered pair form......-  gt\n");
                 gets(exp);
                 len=strlen(exp);
                 /*------------------------Distinct alphabet Calculation---------------------*/

                                printf("\n..Counting distinct elements in the relaion are....\n");
    dis_opr[ret]=exp[0];
    printf("%c\t",dis_opr[ret]);
    ret++;
    for(n=0;n lt len;n++)
    {
        for(r=n+1;rgt=0;r--)
        {
            if(exp[n+1]==exp[r-1])
            {
                dis=0;
                break;
            }
            else
            {
                dis=1;
            }
        }
        if(dis==1)
        {
            if(exp[n+1]!=',')
            {
                dis_opr[ret]=exp[n+1];
                printf("%c\t",dis_opr[ret]);
                ret++;
            }
        }
    }
        //printf("\n.....No Of Distinct Operands are....%d",ret-1);
        if(len1gtret)
        {
            printf("\n.......Relation Dont Have equal no of Distinct elements as in the set.........\n");
            printf("\n....No Need To Check Further -------------- Non Equivalence Relation.........\n");
            return 0;
        }


        /*---------------Starting The Reflexive Chech--------------------------*/
        int i=0,j,count=0,flag1;
        while(i lt ret)
        {
                for(j=0;j lt len;j++)
                {
                    if(exp[j]  gt='a' && exp[j] lt='z' && exp[j+1]  gt='a' && exp[j+1] lt='z' && exp[j+2]  gt='a' && exp[j+2] lt='z' || exp[j]==',' && exp[j+1]==',')
                    {
                          printf("\n...Input is not given in ordered pair form.....\n");
                          printf("\n...Can't proceed further......\n");
                          return 0;
                    }
                    if(exp[j]==',' && dis_opr[i]==exp[j+1] && dis_opr[i]==exp[j+2])
                    {

                            printf("\n...The Reflex Element is...%c",dis_opr[i]);
                            count++;
                    }
                    if(dis_opr[i]==exp[j] && dis_opr[i]==exp[j+1] && j==0)
                    {
                            printf("\n...The Reflex Element is....%c",dis_opr[i]);
                            count++;
                    }

                }//end of nested for loop................
            i++;
        }//end of outer most for loop......................
                    if(countgt=ret-1)
                    {
                        printf("\n....The Relation is Reflexive.....\n");
                        flag1=1;
                    }
                    else
                    {
                        printf("\n...Relation is  Not Reflexive...........\n");
                        flag1=0;
                    }
        i=0;
        j=0;
        int ch,in_ch,sym=1,flag2,com=0;
        char u,v,u1,v1;
        /*------------------------------Starting The Symmetric Checking----------------------------*/
                        u1=exp[i];
                        v1=exp[i+1];
                        in_ch=sym_ch(u1,v1);
                            if(in_ch==1 || in_ch==-1)
                            {
                                for(i=2;i lt= len;i++)
                                {
                                    if(exp[i]==',')
                                    {
                                        com++;
                                        u=exp[i+1];
                                        v=exp[i+2];
                                        if(u!=v)
                                        {
                                            ch=sym_ch(u,v);

                                            if(ch==1)
                                            {
                                                sym=1;
                                                continue;
                                            }
                                            else
                                            {
                                                sym=0;
                                                break;
                                            }
                                        }//end of oneual character if block.........
                                    }
                                }//end of for loop
                            }//end of if block.................
                                //printf("\ncomma=%d",com-1);
                                //printf("\n....The %d th Ordered Pair has no symmetric elemrnt",((i-com+1)/2)+1);

                                if(in_ch==0 || sym==0)
                                {
                                    printf("\n.....Relation is not Symmetric...........\n");
                                    printf("\n....The %d th Ordered Pair has no symmetric Pair",((i-com+1)/2)+1);
                                    //printf("\n.....Rest not Checked...........\n");
                                    flag2=0;
                                }
                                else if(in_ch==1 && sym==1 || in_ch==-1 && sym==1)
                                {
                                    printf("\n....Relation is totally Symmetric.......\n");
                                    flag2=1;
                                }

              /*-----------------------------------Starting The Transtion Checkig---------------------------*/

        char ch1,ch2;
        int g,cnt,chc,flag3;

    for(g=0;g lt len;g++)
     {
            if(exp[g]==',' || g==0)
            {
                if(exp[g]==',')
                {
                ch1=exp[g+1];
                ch2=exp[g+2];
                        cnt=part_one(ch1,ch2);
                }
                else if(g==0)
                {
                    ch1=exp[g];
                    ch2=exp[g+1];
                    //printf("\t%c%c",ch1,ch2);
                        cnt=part_one(ch1,ch2);
                }
            }
            //printf("\n..CONT==%d",cnt);
            if(cnt==1)
            {
                chc=1;
            }
            else if(cnt==0)
            {
                chc=0;
                break;
            }
     }

        //printf("\nCHC======%c",chc);
            if(chc==0)
            {
                printf("\n....The Relation is  not Transitive Relation........\n");
                flag3=0;
            }
            else if(chc==1)
            {
                printf("\n....The Relation is a perfectly Transition Relation.......\n");
                flag3=1;
            }

            if(flag1==1 && flag2==1 && flag3==1)
            {
                    printf("\n......Realition is Equivalence..........\n");
            }
            else
            {
                    printf("\n......Non Equivalence Relation...........\n");
            }
    return 0;
}
int sym_ch(char u,char v)
{
    //printf("\t%c%c\t",u,v);
    char ch1,ch2;
    int len,c,count=0;
    len=strlen(exp);
    ch1=u;
    ch2=v;
        //printf("\t%c%c\t",ch1,ch2);
                    if(ch1==ch2)
                    {
                        return(-1);
                    }
            for(c=0;c lt len;c++)
            {
                    if(c==0)
                    {
                        if(ch2==exp[c] && ch1==exp[c+1])
                        {
                            count=1;
                            printf("\n...The Symmetric Elements are-  gt %c %c",ch1,ch2);
                            break;
                        }
                    }
                    else if(exp[c]==',')
                    {
                            if(ch2==exp[c+1] && ch1==exp[c+2])
                            {
                                    printf("\n...The Symmetric Elements are-  gt %c %c",ch1,ch2);
                                    count=1;
                                    break;
                            }

                    }
                    else
                    {
                            count=0;
                    }
                }//end of for loop.........
                printf("\nCOUNT====%d",count);

                return(count);
}
int part_one(char u,char v)
{
    char x,y,three;
    int i,cont,flg=1,len;
    x=u;
    y=v;
        len=strlen(exp);
        //printf("\n Rajdeep.........%c%c",x,y);
        //printf("Cont====%d",cont);
            for(i=0;i lt len;i++)
            {
                    if(exp[i]==',' || i==0)
                    {
                        //printf("Rajdeep");
                        if(exp[i]==',' && y==exp[i+1])
                        {
                            three=exp[i+2];
                            //printf("\t%c",three);
                            cont=part_two(x,three);
                        }
                        if(i==0 && y==exp[i])
                        {
                            three=exp[i+1];
                            //printf("\t.....Three is %c",three);
                            cont=part_two(x,three);
                        }
                    }
                        if(cont==1)
                        {
                            flg=1;
                        }
                        else if(cont==0)
                        {
                            flg=0;
                            break;
                        }

            }
                false++;
                printf("\nFlag is==%d",flg);
                if(flg==1)
                {
                    //false++;
                    return(1);
                }
                else
                {
                    //false++;
                    printf("\n....%d th pair is responsible for Non- Transitive.......",false);
                    return(0);
                }
}
int part_two(char p,char q)
{
    char w,z;
    int j,swap,len;
    w=p;
    z=q;
        len=strlen(exp);
              for(j=0;j lt len-1;j++)
              {
                    if(w==exp[j] && z==exp[j+1])
                    {
                        swap=1;
                        break;
                    }
                    else
                    {
                        swap=0;
                    }
              }
              //printf("\n Swap is===%d",swap);
    return(swap);
}




prog 7:) Code to check a graph is connected or not??


 #include stdio.h
#include conio.h
#include stdlib.h
#include string.h
#define BOUND 100
void connected(struct stack *p);
int repeat(int x);
void present();
void push(struct stack *p,int ele);
int pop(struct stack *p);
struct stack
{
     int top;
     int str[BOUND];
};
struct stack stk;
void push(struct stack *p, int ele)
{
        if(p-gt top==BOUND-1)
        {
             printf("\nStack Overflow");
             exit(1);
        }
        else
        {
             p-gt top++;
             p-gt str[p-gttop]=ele;
        }
}
int pop(struct stack *p)
{
     int ret;
     if(p-gt top==-1)
     {
         printf("\nStack Underflow");
         exit(1);
     }
     else
     {
         ret=p-gt str[p-gttop];
         p-gt top--;
     }
return ret;
}
int node,arr[30],bound=0;
int adj_mat[20][20];
int main()
{
     struct stack *p;
     p=&stk;
     p-gttop=-1;
     int i,j,temp;
     printf("\nNum of nodes of Graph Are=");
     scanf("%d",&node);
     printf("\nPress 1 if edge is present else press 0");
     for(i=0;i lt node;i++)
     {
          for(j=0;j lt node;j++)
          {
              adj_mat[i][j]=-1;
          }
     }
     i=0;
     j=0;
     printf("\nInput The Edges From The User");
     for(i=0;i lt node;i++)
     {
          for(j=i+1;j lt node;j++)
          {
                printf("\nAn Edge is Present between %d th node and %d th node or not(y/n)=",i+1,j+1);
                scanf("%d",&temp);
                adj_mat[i][j]=temp;
                adj_mat[j][i]=temp;
          }
     }
     i=0;
     push(p,i);
     arr[bound++]=i;
     connected(p);
getch();
return 0;
}
void connected(struct stack *p)
{
    int col,flag=0,row,ch;
    col=0;
    while(p-gttop!=-1)
    {
         row=pop(p);
         push(p,row);
         while(col lt node)
         {
             if(adj_mat[row][col]==1)
             {
                  ch=repeat(col);
                  if(ch==1)
                  {
                     push(p,col);
                     arr[bound++]=col;
                     flag=1;
                     col=0;
                     break;
                  }
             }
         col++;
      }//end of inner while loop
      if(flag==1)
      {
            flag=0;
      }
      else
      {
            pop(p);
            col=0;
      }
    }//end of outer while loop
    present();
}
void present()
{
  int j;
  if(node==bound)
  {
      printf("\n\n-------------------------------------------");
      printf("\n\n\t\tConnected Graph");
      printf("\n\n-------------------------------------------");
  }
  else
  {
      printf("\n\n-------------------------------------------");
      printf("\n\n\t\tDisconnected Graph");
      printf("\n\n-------------------------------------------");
  }
}
int repeat(int m)
{
    int k;
    for(k=0;k lt bound;k++)
    {
         if(m==arr[k])
         {
            return 0;
         }
    }
return 1;
}