SAVEETHA SCHOOL OF ENGINEERING

SAVEETHA INSTITUTE OF MEDICAL AND

TECHNICAL SCIENCES

COMPUTER SCIENCE AND ENGINEERING PROGRAMME

LAB MANUAL

CS019

THEORY OF COMPUTATION

(Regulation 2016)
 SAVEETHA SCHOOL OF ENGINEERING

SAVEETHA INSTITUTE OF MEDICAL AND

TECHNICAL SCIENCES

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING PROGRAMME

LIST OF EXPERIMENTS

COURSE CODE : CS019

COURSE NAME : THEORY OF COMPUTATION

1. Write a C program to simulate a Deterministic Finite Automata (DFA)

for the given language.
2. Write a C program to simulate a Non-Deterministic Finite Automata
(NFA) for the given language.
3. Write a C program to find ε-closure for all the states in a Non-
Deterministic Finite Automata (NFA) with ε -moves.
4. Write a C program to check whether a given string belongs to the
language defined by a Context Free Grammar (CFG)
5. Write a C program to simulate a Push Down Automata (PDA) for the
language 0n1n.
6. Write a C program to simulate a Push Down Automata (PDA) for the
language anb2n.
7. Write a C program to simulate a Turing Machine (TM) for the given
language.
8. CASE STUDY – A real time application of Finite Automata.
EXP NO : 1

DETERMINISTIC FINITE AUTOMATA (DFA)

AIM :

To write a C program to simulate a Deterministic Finite Automata.

ALGORTIHM :

1. Draw a DFA for the given language and construct the transition table.
2. Store the transition table in a two-dimensional array.
3. Initialize present_state, next_state and final_state
4. Get the input string from the user.
5. Find the length of the input string.
6. Read the input string character by character.
7. Repeat step 8 for every character
8. Refer the transition table for the entry corresponding to the present
state and the current input symbol and update the next state.
9. When we reach the end of the input, if the final state is reached, the
input is accepted. Otherwise the input is not accepted.
Example:
Simulate a DFA for the language representing strings over 𝚺={a,b} that start
with a and end with b

Design of the DFA

Transition Table:

State / Input a b
→0 1 3
1 1 2
2 1 2
3 3 3

PROGRAM :

#include<stdio.h>
#include<string.h>
#define max 20
int main()
{
int trans_table[4][2]={{1,3},{1,2},{1,2},{3,3}};
int final_state=2,i;
int present_state=0;
int next_state=0;
int invalid=0;
char input_string[max];
 printf("Enter a string:");
scanf("%s",input_string);
int l=strlen(input_string);
for(i=0;i<l;i++)
{
if(input_string[i]=='a')
next_state=trans_table[present_state][0];
else if(input_string[i]=='b')
next_state=trans_table[present_state][1];
else
invalid=l;
present_state=next_state;
}
if(invalid==l)
{
printf("Invalid input");
}
else if(present_state==final_state)
printf("Accept\n");
else
printf("Don't Accept\n");
}

OUTPUT
EXP NO : 2

NON-DETERMINISTIC FINITE AUTOMATA (NFA)

AIM :

To write a C program to simulate a Non-Deterministic Finite Automata.

ALGORTIHM :

1. Get the following as input from the user.

i. Number of states in the NFA
ii. Number of symbols in the input alphabet and the symbols
iii. Number of final states and their names
2. Declare a 3-dimensional matrix to store the transitions and initialize
all the entries with -1
3. Get the transitions from every state for every input symbol from the
user and store it in the matrix.
For example, consider the NFA shown below.

There are 4 states 0, 1, 2 and 3

 There are two input symbols a and b. As the array index always
starts with 0, we assume 0th symbol is a and 1st symbol is b.
The transitions will be stored in the matrix as follows:
From state 0, for input a, there are two transitions to state 0 and 1,
which can be stored in the matrix as
m[0][0][0]=0
m[0][0][1]=1
Similarly, the other transitions can be stored as follows:
m[0][1][0]=0 (From state 0, for input b, one transition is to state 0)
m[0][1][1]=2 (From state 0, for input b, next transition is to state 2)
m[1][1][0]=3 (From state 1, for input b, move to state 3)
m[2][0][0]=3 (From state 2, for input a, move to state 3)
m[3][0][0]=3 (From state 3, for input a, move to state 3)
m[3][1][0]=3 (From state 3, for input b, move to state 3)
All the other entries in the matrix will be -1 indicating no moves
4. Get the input string from the user.
5. Find the length of the input string.
6. Read the input string character by character.
7. Repeat step 8 for every character
8. Refer the transition table for the entry corresponding to the present
state and the current input symbol and update the next state. As
there can be more than one transition, the next state will be an array.
9. From every state in the next state array, find the list of new
transitions and update the next state array.
10. When we reach the end of the input, if at least one of the final states
is present in the next state array, it means there is a path to a final
state. So the input is accepted. Otherwise the input is not accepted.
PROGRAM :

#include<stdio.h>
#include<string.h>
int main()
{
int i,j,k,l,m,next_state[20],n,mat[10][10][10],flag,p;
int num_states,final_state[5],num_symbols,num_final;
int present_state[20],prev_trans,new_trans;
char ch,input[20];
int symbol[5],inp,inp1;
printf("How many states in the NFA : ");
scanf("%d",&num_states);
printf("How many symbols in the input alphabet : ");
scanf("%d",&num_symbols);
for(i=0;i<num_symbols;i++)
{
printf("Enter the input symbol %d : ",i+1);
scanf("%d",&symbol[i]);
}
printf("How many final states : ");
scanf("%d",&num_final);
for(i=0;i<num_final;i++)
{
printf("Enter the final state %d : ",i+1);
scanf("%d",&final_state[i]);
}
//Initialize all entries with -1 in Transition table
for(i=0;i<10;i++)
{
for(j=0;j<10;j++)
{
for(k=0;k<10;k++)
{
mat[i][j][k]=-1;
}
}
}
//Get input from the user and fill the 3D transition table
for(i=0;i<num_states;i++)
{
for(j=0;j<num_symbols;j++)
{
printf("How many transitions from state %d for the input %d :
",i,symbol[j]);
scanf("%d",&n);
for(k=0;k<n;k++)
{
 printf("Enter the transition %d from state %d for the input
%d : ",k+1,i,symbol[j]);
scanf("%d",&mat[i][j][k]);
}
}
}
printf("The transitions are stored as shown below\n");
for(i=0;i<10;i++)
{
for(j=0;j<10;j++)
{
for(k=0;k<10;k++)
{
if(mat[i][j][k]!=-1)
printf("mat[%d][%d][%d] = %d\n",i,j,k,mat[i][j][k]);
}
}
}
while(1)
{
printf("Enter the input string : ");
scanf("%s",input);
present_state[0]=0;
prev_trans=1;
l=strlen(input);
for(i=0;i<l;i++)
{
if(input[i]=='0')
inp1=0;
else if(input[i]=='1')
inp1=1;
else
{
printf("Invalid input\n");
exit(0);
}
for(m=0;m<num_symbols;m++)
{
if(inp1==symbol[m])
{
inp=m;
break;
}
}
new_trans=0;
for(j=0;j<prev_trans;j++)
{
k=0;
p=present_state[j];
 while(mat[p][inp][k]!=-1)
{
next_state[new_trans++]=mat[p][inp][k];
k++;
}
}
for(j=0;j<new_trans;j++)
{
present_state[j]=next_state[j];
}
prev_trans=new_trans;
}
flag=0;
for(i=0;i<prev_trans;i++)
{
for(j=0;j<num_final;j++)
{
if(present_state[i]==final_state[j])
{
flag=1;
break;
}
}
}
if(flag==1)
printf("Acepted\n");
else
printf("Not accepted\n");
printf("Try with another input\n");
}
}

Example:
Simulate a NFA for the language representing strings over 𝚺={a,b} that start
and end with the same symbol
Design of the NFA
Transition Table
State / Input 0 1
→0 1 3
1 {1,2} 1
2 - -
3 3 {2,3}

OUTPUT:
EXP NO : 3

FINDING ε-CLOSURE FOR NFA WITH ε-MOVES

AIM :

To write a C program to find ε-closure of a Non-Deterministic Finite

Automata with ε-moves

ALGORTIHM :

1. Get the following as input from the user.

i. Number of states in the NFA
ii. Number of symbols in the input alphabet including ε
iii. Input symbols
iv. Number of final states and their names
2. Declare a 3-dimensional matrix to store the transitions and initialize
all the entries with -1
3. Get the transitions from every state for every input symbol from the
user and store it in the matrix.
For example, consider the NFA shown below.

There are 3 states 0, 1, and 2

There are three input symbols ε, 0 and 1. As the array index always
starts with 0, we assume 0th symbol is ε, 1st symbol is 0 and 2nd
symbol is 1.
 The transitions will be stored in the matrix as follows:
From state 0, for input ε, there is one transition to state 1, which can
be stored in the matrix as
m[0][0][0]=1
From state 0, for input 0, there is no transition.
From state 0, for input 1, there is one transition to state 1, whichcan
be stored in the matrix as
m[0][2][0]=1
Similarly, the other transitions can be stored as follows:
m[1][0][0]=2 (From state 1, for input ε, the transition is to state 2)
m[1][1][0]=1 (From state 1, for input 0, the transition is to state 1)
All the other entries in the matrix will be -1 indicating no moves
4. Initialize a two-dimensional matrix e_closure with -1 in all the
entries.
5. ε-closure of a state q is defined as the set of all states that can be
reached from state q using only ε-transitions.
Example:
Consider the NFA with ε-transitions given below:

ε-closure(0)={0,1,2)
ε-closure(1)={1,2}
ε-closure(2)={2}
Here, we see that ε-closure of every state contains that state first. So
initialize the first entry of the array e_closure with the same state.
e_closure(0,0)=0;
 e_closure(1,0)=1;
e_closure(2,0)=2;
6. For every state i, find ε-closure as follows:
If there is an ε-transition from state i to state j, add j to the matrix
e_closure[i]. Call the recursive function find_e_closure(j) and add
the other states that are reachable from i using ε
7. For every state, print the ε-closure values

The function find_e_closure(i)

This function finds ε-closure of a state recursively by tracing all the ε-
transitions

PROGRAM :

#include<stdio.h>
#include<string.h>
int trans_table[10][5][3];
char symbol[5],a;
int e_closure[10][10],ptr,state;
void find_e_closure(int x);
int main()
{
int i,j,k,n,num_states,num_symbols;
for(i=0;i<10;i++)
{
for(j=0;j<5;j++)
{
for(k=0;k<3;k++)
{
trans_table[i][j][k]=-1;
}
}
}
printf("How may states in the NFA with e-moves:");
scanf("%d",&num_states);
printf("How many symbols in the input alphabet including e :");
scanf("%d",&num_symbols);
printf("Enter the symbols without space. Give 'e' first:");
scanf("%s",symbol);
for(i=0;i<num_states;i++)
{
for(j=0;j<num_symbols;j++)
 {
printf("How many transitions from state %d for the input
%c:",i,symbol[j]);
scanf("%d",&n);
for(k=0;k<n;k++)
{
printf("Enter the transitions %d from state %d for the input
%c :", k+1,i,symbol[j]);
scanf("%d",&trans_table[i][j][k]);
}
}
}
for(i=0;i<10;i++)
{
for(j=0;j<10;j++)
{
e_closure[i][j]=-1;
}
}
for(i=0;i<num_states;i++)
e_closure[i][0]=i;
for(i=0;i<num_states;i++)
{

if(trans_table[i][0][0]==-1)
continue;
else
{
state=i;
ptr=1;
find_e_closure(i);
}
}
for(i=0;i<num_states;i++)
{
printf("e-closure(%d)= {",i);
for(j=0;j<num_states;j++)
{
if(e_closure[i][j]!=-1)
{
printf("%d, ",e_closure[i][j]);
}
}
printf("}\n");
}
}
void find_e_closure(int x)
{
 int i,j,y[10],num_trans;
i=0;
while(trans_table[x][0][i]!=-1)
{
y[i]=trans_table[x][0][i];
i=i+1;
}
num_trans=i;
for(j=0;j<num_trans;j++)
{
e_closure[state][ptr]=y[j];
ptr++;
find_e_closure(y[j]);
}
}

Example:

Find ε-closure for all the states for the NFA with ε-moves given below:

0 1 2

TRANSITION TABLE :

State / Input ε 0 1
→0 1 - 1
1 2 {0,1} -
2 - - -
OUTPUT :
EXP NO : 4

CHECKING WHETHER A STRING BELONGS TO A GRAMMAR

Ex 4 a
AIM :

To write a C program to check whether a string belongs to the grammar

S→0A1
A→0A|1A|ε

Language defined by the Grammar:

Set of all strings over 𝚺={0,1} that start with 0 and end with 1

ALGORTIHM :
1. Get the input string from the user.
2. Find the length of the string.
3. Check whether all the symbols in the input are either 0 or 1. If so,
print “String is valid” and go to step 4. Otherwise print “String not
valid” and quit the program.
4. If the first symbol is 0 and the last symbol is 1, print “String
accepted”. Otherwise, print “String not accepted”
PROGRAM :

#include<stdio.h>
#include<string.h>
int main(){
char s[100];
int i,flag;
int l;
printf("enter a string to check:");
scanf("%s",s);
l=strlen(s);
flag=1;
for(i=0;i<l;i++)
{
if(s[i]!='0' && s[i]!='1')
{
flag=0;
}
}
if(flag!=1)
printf("string is Not Valid\n");
if(flag==1)
{
if (s[0]=='0'&&s[l-1]=='1')
printf("string is accepted\n");
else
printf("string is Not accepted\n");
}
}
OUTPUT :
EXP 4 b
CHECKING WHETHER A STRING BELONGS TO A GRAMMAR

AIM :

To write a C program to check whether a string belongs to the grammar

S -> 0 S 0 | 1 S 1 | 0 | 1 | ε

Language defined by the Grammar

Set of all strings over 𝚺={0,1} that are palindrome

ALGORITHM :

1. Get the input string from the user.

2. Find the length of the string. Let it be n.
3. Check whether all the symbols in the input are either 0 or 1. If so,
print “String is valid” and go to step 4. Otherwise print “String not
valid” and quit the program.
4. If the 1st symbol and nth symbol are the same, 2nd symbol and (n-1)th
symbol are the same and so on, then the given string is palindrome.
So, print “String accepted”. Otherwise, print “String not accepted”
PROGRAM :

#include<stdio.h>
#include<string.h>
void main()
{
char s[100];
int i,flag,flag1,a,b;
int l;
printf("enter a string to check:");
scanf("%s",s);
l=strlen(s);
flag=1;
for(i=0;i<l;i++)
{
if(s[i]!='0' && s[i]!='1')
{
flag=0;
}
}
if(flag!=1)
printf("string is Not Valid\n");
if(flag==1)
{
flag1=1;
a=0;b=l-1;
while(a!=(l/2))
{
if(s[a]!=s[b])
{
flag1=0;
}
a=a+1;
b=b-1;
}
if (flag1==1)
{
printf("The string is a palindrome\n");
printf("string is accepted\n");
}
else
{
printf("The string is not a palindrome\n");
printf("string is Not accepted\n");
}
}
}
OUTPUT :
EXP 4 c
CHECKING WHETHER A STRING BELONGS TO A GRAMMAR

AIM :

To write a C program to check whether a string belongs to the grammar

S -> 0 S 0 | A
A -> 1 A | ε

Language defined by the Grammar

Set of all strings over 𝚺={0,1} satisfying 0n1m0n

ALGORITHM :

1. Get the input string from the user.

2. Find the length of the string.
3. Check whether all the symbols in the input are either 0 or 1. If so,
print “String is valid” and go to step 4. Otherwise print “String not
valid” and quit the program.
4. Read the input string character by character
5. Count the number of 0’s in the front and store it in the variable
count1
6. Skip all 1’s
7. Count the number of 0’s in the end and store it in the variable count2
8. If count1==count2, print “String Accepted”. Otherwise print “String
Not Accepted”
PROGRAM :

#include<stdio.h>
#include<string.h>
void main()
{
char s[100];
int i,flag,flag1,a,b;
int l,count1,count2;
printf("enter a string to check:");
scanf("%s",s);
l=strlen(s);
flag=1;
for(i=0;i<l;i++)
{
if(s[i]!='0' && s[i]!='1')
{
flag=0;
}
}
if(flag!=1)
printf("string is Not Valid\n");
if(flag==1)
{
i=0;count1=0;
while(s[i]=='0') // Count the no of 0s in the front
{
count1++;
i++;
}
while(s[i]=='1')
{
i++; // Skip all 1s
}
flag1=1;
count2=0;
while(i<l)
{
if(s[i]=='0')// Count the no of 0s at the end
{
count2++;
}
else
{
flag1=0;
}
i++;
}
 if(flag1==1)
{
if(count1==count2)
{
printf("The string satisfies the condition 0n1m0n\n");
printf ("String Accepted\n");
}
else
{
printf("The string does not satisfy the condition 0n1m0n\n");
printf("String Not Accepted\n");
}
}
else
{
printf("The string does not satisfy the condition 0n1m0n\n");
printf("String Not Accepted\n");
}
}
}

OUTPUT :
EXP 4 d

CHECKING WHETHER A STRING BELONGS TO A GRAMMAR

AIM :

To write a C program to check whether a string belongs to the grammar

S -> 0 S 1 | ε

Language defined by the Grammar

Set of all strings over 𝚺={0,1} satisfying 0n1n

ALGORITHM :

1. Get the input string from the user.

2. Find the length of the string.
3. Check whether all the symbols in the input are either 0 or 1. If so,
print “String is valid” and go to step 4. Otherwise print “String not
valid” and quit the program.
4. Find the length of the string. If the length is odd, then print “String
not accepted” and quit the program. If the length is even, then go to
step 5.
5. Divide the string into two halves.
6. If the first half contains only 0s and the second half contains only 1s
then print “String Accepted”. Otherwise print “String Not Accepted”
PROGRAM :

#include<stdio.h>
#include<string.h>
void main()
{
char s[100];
int i,flag,flag1,flag2;
int l;
printf("enter a string to check:");
scanf("%s",s);
l=strlen(s);
flag=1;
for(i=0;i<l;i++)
{
if(s[i]!='0' && s[i]!='1')
{
flag=0;
}
}
if(flag!=1)
printf("string is Not Valid\n");
if(flag==1)
{
if(l%2!=0) // If string length is odd
{
printf("The string does not satisfy the condition 0n1n\n");
printf("String Not Accepted\n");
}
else
{
// To check first half contains 0s
flag1=1;
for(i=0;i<(l/2);i++)
{
if(s[i]!='0')
{
flag1=0;
}
}
// To check second half contains 1s
flag2=1;
for(i=l/2;i<l;i++)
{
if(s[i]!='1')
{
flag2=0;
}
}
 if(flag1==1 && flag2==1)
{
printf("The string satisfies the condition 0n1n\n");
printf("String Accepted\n");
}
else
{
printf("The string does not satisfy the condition 0n1n\n");
printf("String Not Accepted\n");
}
}
}
}

OUTPUT :
EXP 4 e

CHECKING WHETHER A STRING BELONGS TO A GRAMMAR

AIM :

To write a C program to check whether a string belongs to the grammar

S -> A 1 0 1 A
A -> 0 A | 1 A | ε

Language defined by the Grammar

Set of all strings over 𝚺={0,1} having 101 as a substring

ALGORITHM :

1. Get the input string from the user.

2. Find the length of the string.
3. Check whether all the symbols in the input are either 0 or 1. If so,
print “String is valid” and go to step 4. Otherwise print “String not
valid” and quit the program.
4. Read the input string character by character
5. If the ith input symbol is 1, check whether (i+1)th symbol is 0 and
(i+2)th symbol is 1. If so, the string has the substring 101. So print
“String Accepted”. Otherwise, print “String Not Accepted”
PROGRAM :

#include<stdio.h>
#include<string.h>
int main()
{
char s[100];
int i,flag,flag1;
int l;
printf("enter a string to check:");
scanf("%s",s);
l=strlen(s);
flag=1;
for(i=0;i<l;i++)
{
if(s[i]!='0' && s[i]!='1')
{
flag=0;
}
}
if(flag==1)
printf("string is Valid\n");
else
printf("string is Not Valid\n");
if(flag==1)
{
flag1=0;
for(i=0;i<l-2;i++)
{
if(s[i]=='1')
{
if(s[i+1]=='0' && s[i+2]=='1')
{
flag1=1;
printf("Substring 101 exists. String accepted\n");
break;
}
}
}
if(flag1==0)
printf("Substring 101 does not exist. String not accepted\n");
}
}
OUTPUT :
EXP NO : 05

SIMULATING PUSHDOWN AUTOMATA(PDA)

AIM :

To write a C program to simulate a PDA for the language L={ 0n 1n | n>=1 }

in which equal number of 0’s are followed by equal number of 1’s

ALGORITHM :

1. Get the input string from the user.

2. Define a stack and push the symbol ‘Z’ onto the stack. The symbol ‘Z’
acts as the bottom marker of the stack.
3. Find the length of the string.
4. Read the input string character by character.
5. Read the current input symbol do steps 6 and 7. If the end of the
input is reached, go to step 8
6. If the input symbol is 0, push it onto the stack. Print the content of
the stack and the remaining input and go to step 5
7. If the input symbol is 1, check whether there is a 0 at the top of the
stack. If so, pop it from the stack. Print the content of the stack and
the remaining input and go to step 5. If not, print “String not
accepted” and quit the program
8. If the stack is empty having only the bottom marker, print “String
Accepted”. Otherwise print “String not accepted”.
PROGRAM :

#include<stdio.h>
#include<string.h>
char stack[20];
int top;
void push()
{
top=top+1;
stack[top]='0';
stack[top+1]='\0';
}
int pop()
{
if(top<1)
return(0);
else
{
stack[top]='\0';
top=top-1;
return(1);
}
}
void main()
{
int m,i,j,k,l,a,len;
char input[20],rem_input[20];
printf("Simulation of Pushdown Automata for 0n1n\n");
printf("Enter a string : ");
scanf("%s",input);
l=strlen(input);
j=0;stack[0]='Z';top=0;
printf("Stack\tInput\n");
printf("%s\t%s\n",stack,input);
while(1)
{
len=strlen(input);
while(len>0)
{
if(input[0]=='0')
{
push();
m=0;
for(k=1;k<len;k++)
{
rem_input[m]=input[k];
m=m+1;
}
 rem_input[m]='\0';
strcpy(input,rem_input);
printf("%s\t%s\n",stack,input);
}
if(input[0]=='1')
{
a=pop();
if(a==0)
{
printf("String not accepted");
goto b;
}
else
{
m=0;
for(k=1;k<len;k++)
{
rem_input[m]=input[k];
m=m+1;
}
rem_input[m]='\0';
strcpy(input,rem_input);
printf("%s\t%s\n",stack,input);
}
}
break;
}
j=j+1;
if(j==(l))
{
break;
}
}
if(top>=1)
{
printf("String not accepted");
}
else
{
printf("String accepted");
}
b:
printf(".............");
}
OUTPUT :
EXP NO : 06

SIMULATING PUSHDOWN AUTOMATA(PDA)

AIM :

To write a C program to simulate a PDA for the language L={ 0n 12n | n>=1 }
in which n number of 0’s are followed by 2n number of 1’s

ALGORITHM :

1. Get the input string from the user.

2. Define a stack and push the symbol ‘Z’ onto the stack. The symbol ‘Z’
acts as the bottom marker of the stack.
3. Initialize a variable count=0
4. Find the length of the string.
5. Read the input string character by character.
6. Read the current input symbol do steps 7 and 8. If the end of the
input is reached, go to step 9
7. If the input symbol is 0, push it onto the stack. Print the content of
the stack and the remaining input and go to step 6
8. If the input symbol is 1
a. Increment count.
b. If count is odd, go to step 6 to read the next input symbol
c. If count is even, check whether there is a 0 at the top of the
stack. If so, pop it from the stack. Print the content of the stack
and the remaining input and go to step 6. If not, print “String
not accepted” and quit the program
9. If the stack is empty having only the bottom marker, print “String
Accepted”. Otherwise print “String not accepted”.
PROGRAM:

#include<stdio.h>
#include<string.h>
char stack[20];
int top,count=0;
void push()
{
top=top+1;
stack[top]='0';
stack[top+1]='\0';
}
int pop()
{
if(top<1)
return(0);
else
{
stack[top]='\0';
top=top-1;
return(1);
}
}
void main()
{
int m,i,j,k,l,a,len;
char input[20],rem_input[20];
printf("Simulation of PDA for n 0's followed by 2n 1's\n");
printf("Enter a string : ");
scanf("%s",input);
l=strlen(input);
j=0;stack[0]='Z';top=0;
printf("Stack\tInput\n");
printf("%s\t%s\n",stack,input);
while(1)
{
len=strlen(input);
while(len>0)
{
if(input[0]=='0')
{
push();
m=0;
for(k=1;k<len;k++)
{
rem_input[m]=input[k];
m=m+1;
}
rem_input[m]='\0';
 strcpy(input,rem_input);
printf("%s\t%s\n",stack,input);
}
if(input[0]=='1')
{
count++;
if(count%2==0)
{
a=pop();
if(a==0)
{
printf("String not accepted");
goto b;
}
else
{
m=0;
for(k=1;k<len;k++)
{
rem_input[m]=input[k];
m=m+1;
}
}
rem_input[m]='\0';
strcpy(input,rem_input);
printf("%s\t%s\n",stack,input);
}
else
{
m=0;
for(k=1;k<len;k++)
{
rem_input[m]=input[k];
m=m+1;
}
rem_input[m]='\0';
strcpy(input,rem_input);
printf("%s\t%s\n",stack,input);
}
}
break;
}
j=j+1;
//printf("j = %d\t l = %d\n",j,l);
if(j==l)
{
break;
}
}
 if(top>=1)
{
printf("String not accepted");
}
else
{
printf("String accepted");
}
b:
printf(".............");
}
OUTPUT :
EXP NO : 07

SIMULATING TURING MACHINE

AIM :

To write a C program to simulate a Turing Machine for the language L={ 0n

1n2n | n>=1 } in which n number of 0’s are followed by 2n number of 1’s

ALGORITHM :

1. Get the input string from the user.

2. Find the length of the string.
3. Read a ‘0’, change it to ‘A’ and move one position to the right
4. Skip all 0’s and B’s if any and move in the right
5. Read a ‘1’, change it to ‘B’ and move one position to the right
6. Skip all 1’s and B’s if any and move in the right
7. Read a ‘2’, change it to ‘C’ and move one position to the left
8. Skip all C’s, 1’s, B’s and 0’s and move left
9. When we read a ‘A’ move one position to the right.
a. If the next symbol is 0, goto step 3.
b. Otherwise, if the next symbol is B, then skip all B’s and move
right. After skipping all B’s
i. If there is a C, then skip all C’s and move in the right.
After skipping all C’s, if we reach the end of the input,
print “String Accepted”, otherwise print “String not
accepted”
ii. If there is a symbol other than C, print “String not
accepted”
10. End the program
PROGRAM :

#include<stdio.h>
#include<string.h>
void main()
{
int i,j,le,flag,flag1,flag2;
char str[20];
printf("Program to show how a turing machine will process 0n1n2n\n");
printf("Enter a string : ");
scanf("%s",str);
le=strlen(str);
j=0;
while(1)
{
flag=0;flag1=0;flag2=0;i=0;
while(i<le)
{
if((str[i]=='0')&&(flag==0))
{
str[i] = 'A';
printf("%s\n",str);
flag=1; //To mark that a 0 is changed to A
i=i+1;
}
else if((str[i]=='0')&&(flag==1))
{
i=i+1; //Skip 0
}
else if(str[i]=='A')
{
i=i+1; //Skip A
}
else if((str[i]=='1')&&(flag1==0))
{
str[i] = 'B';
printf("%s\n",str);
flag1=1; //To mark that a 1 is changed to B
i=i+1;
}
else if((str[i]=='1')&&(flag1==1))
{
i=i+1; //Skip 1
}
else if(str[i]=='B')
{
i=i+1; //Skip B
}
else if((str[i]=='2')&&(flag2==0))
 {
str[i] ='C';
printf("%s\n",str);
flag2=1; //To mark that a 2 is changed to C
i=i+1;
}
else if((str[i]=='2')&&(flag2==1))
{
i=i+1; //Skip 2
}
else if(str[i]=='C')
{
i=i+1; //Skip C
}
}
j=j+1;
if(j==le)
{
break;
}
}
}

OUTPUT
EXP NO : 08

CASE STUDY – REAL-TIME APPLICATION OF AUTOMATA THEORY

EXP NO : 08(A)
DATE :

THE AUTOMATIC TELLER MACHINE (ATM)

AIM: To study and understand the formal design, specification and modelling of the
ATM system using Finite State Machine

FINITE STATE MACHINE (FSM) :

A Finite State Machine is an abstract model of a system (physical, biological, mechanical,

electronic, or software. Key components of a FSM are
• A finite number of states which represent the internal “memory” of the system
by implicitly storing information about what has happened before
• Transitions which represent the “response” of the system to its environment.
Transitions depend upon the current state of the machine as well as the current
input and often result in a change of state.

CONCEPTUAL MODEL OF THE ATM SYSTEM :

An ATM system is a real-time front terminal of automatic teller services with the
support of a central bank server and a centralized account database. The ATM provides
money withdrawal and account balance management services. It encompasses an ATM
processor, a system clock, a remote account database, and a set of peripheral devices
such as the card reader, monitor, keypad, bills storage and bills disburser. The
conceptual model of an ATM system is usually described by a Finite State Machine
(FSM) which adopts a set of states and a set of transitions modelled by a transition
diagram or a transition table to describe the basic behaviours of the ATM system,
FORMAL DEFINITION OF THE FINITE STATE MACHINE :

Formal definition of the finite state machine can be written as

ATM = (Q, 𝚺, δ, q0, F)
where
• Q → set of states {s0, s1, s2, s3, s4, s5, s6, s7}
S0 : System
S1 : Welcome
S2 : Check PIN
S3 : Input withdraw amount
S4 : Verify balance
S5 : Verify bills availability
S6 : Disburse bills
S7 : Eject card
• 𝚺 → set of events that the ATM may accept and process
𝚺 = { e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10}
e0 : Start
e1 : Insert card
e2 : Correct PIN
e3 : Incorrect PIN
e4 : Request ≤ max
 e5 : Request > max
e6 : Cancel transaction
e7 : Sufficient funds
e8 : Insufficient funds
e9 : Sufficient bills in ATM
e10 : Insufficient bills in ATM
• q0 → start state
q0 = s1 (Welcome)
• F → set of accepting states
F = {s1}
• δ → transition function that determines the next state of the FSM on the basis of
the current state and the incoming event. δ is defined as shown in the transition
diagram and the transition table given below.
Transition Diagram :
State Transition Table :

Present state Input (Event) Next State

s0 e0 s1
s1 e1 s2
s2 e2 s3
s2 e3 s2
s2 e6 s7
s3 e4 s4
s3 e5 s3
s3 e6 s7
s4 e7 s5
s4 e8 s7
s5 e9 s6
s5 e10 s7
s6 - s7
s7 - s1

RESULT:

The conceptual model of ATM system, its configuration, basic behaviours and logical
relationships among components of the ATM system are studied.
EXP NO : 8(B)
DATE :

PATTERN SEARCHING

AIM: To study and understand the formal design, specification and modelling of Pattern
Searching / Text Searching using Finite State Machine

FINITE STATE MACHINE (FSM) :

A Finite State Machine is an abstract model of a system (physical, biological, mechanical,

electronic, or software. Key components of a FSM are
• A finite number of states which represent the internal “memory” of the system
by implicitly storing information about what has happened before
• Transitions which represent the “response” of the system to its environment.
Transitions depend upon the current state of the machine as well as the current
input and often result in a change of state.

CONCEPTUAL MODEL OF THE PATTERN MATCHING SYSTEM :

Pattern searching is an important problem in computer science. When we search for a

string in notepad / word file or browser or database, pattern searching algorithms are
used to show the results. Finite Automata (FA) can also be used for pattern searching.
In FA-based pattern searching algorithm, we preprocess the pattern and build a 2D
array that represents a Finite Automata. Construction of the FA is the main tricky part
of this algorithm. Once this FA is built, the searching is simple. In search, we simply
need to start from the first state of the automata and the first character of the text. At
every step, we consider the next character of text, look for the next state in the built FA
and move to a new state. If we reach the final state, then the pattern is found in the text.
The time complexity of the search process is O(n).

FORMAL DEFINITION OF THE FINITE AUTOMATA

A Simple Example:

Suppose a text file consists of only a’s and b’s and the search is for the string “abba”.
The corresponding finite automata will be as follows:
Start searching for the string from the initial state 0 and when the final state 4 is
reached, the search is successful.

A Complex Example :

For example, let us design a Finite Automata for accepting the keywords “ezhil”, “hills”
and “lssbus” in a text file. The Nondeterministic Finite Automata (NFA) can be built
quickly for the given problem. Based on the number of keywords and its length, the size
of the NFA may vary.
Formal definition of the NFA can be written as
N = (Q, 𝚺, δ, q0, F)
where
• Q → set of states {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}
• 𝚺 → input alphabet {a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z}
• q0 → initial state. 1
• F → set of final states {6, 11, 17}
• δ → transition function which is shown below as transition diagram and table

Transition Diagram :
State Transition Table :

Sample Input :

If the given input is

dr ezhilarasu umadevi went to nilgiri hills by lssbus. Ezhil visited many places in
that
hills. On the way, he saw one flex which has the word ezhillssbus

Starting from the initial state, taking the input character by character, if one of the final
states is reached, the input word will be accepted.

SAMPLE C PROGRAM :

// C program for Finite Automata Pattern searching Algorithm

#include<stdio.h>
#include<string.h>
#define NO_OF_CHARS 256

int getNextState(char *pat, int M, int state, int x)

{
// If the character c is same as next character
// in pattern,then simply increment state
if (state < M && x == pat[state])
return state+1;
 // ns stores the result which is next state
int ns, i;

// ns finally contains the longest prefix

// which is also suffix in "pat[0..state-1]c"

// Start from the largest possible value

// and stop when you find a prefix which is also suffix
for (ns = state; ns > 0; ns--)
{
if (pat[ns-1] == x)
{
for (i = 0; i < ns-1; i++)
if (pat[i] != pat[state-ns+1+i])
break;
if (i == ns-1)
return ns;
}
}

return 0;
}

/* This function builds the TF table which represents

Finite Automata for a given pattern */

void computeTF(char *pat, int M, int TF[][NO_OF_CHARS])

{
int state, x;
for (state = 0; state <= M; ++state)
for (x = 0; x < NO_OF_CHARS; ++x)
TF[state][x] = getNextState(pat, M, state, x);
}

/* Prints all occurrences of pat in txt */

void search(char *pat, char *txt)

{
int M = strlen(pat);
int N = strlen(txt);

int TF[M+1][NO_OF_CHARS];
 computeTF(pat, M, TF);

// Process txt over FA.

int i, state=0;
for (i = 0; i < N; i++)
{
state = TF[state][txt[i]];
if (state == M)
printf ("\n Pattern found at index %d",
i-M+1);
}
}

// Driver program to test above function

int main()
{
char *txt = "AABAACAADAABAAABAA";
char *pat = "AABA";
search(pat, txt);
return 0;
}

RESULT:

The conceptual model of the pattern searching system, the method for constructing
NFA for the required keywords and searching for the required keywords in a text
file are studied.
EXP NO : 8(C)
DATE :

VENDING MACHINE

AIM: To study and understand the formal design, specification and modelling of
Vending Machine using Finite State Machine

FINITE STATE MACHINE (FSM) :

A Finite State Machine is an abstract model of a system (physical, biological, mechanical,
electronic, or software. Key components of a FSM are
• A finite number of states which represent the internal “memory” of the system by
implicitly storing information about what has happened before
• Transitions which represent the “response” of the system to its environment.
Transitions depend upon the current state of the machine as well as the current
input and often result in a change of state.

CONCEPTUAL MODEL OF THE VENDING MACHINE :

Vending machines (VM) are electronic devices used to provide different products such
as snacks, coffee, tickets, etc. Vending machines provide several different types of items
when money is inserted into it. The Vending machines are more practical, easy to use
and accessible for user than the standard purchasing method. The efficient
implementation of these machines can be in different ways by using microcontroller
and FPGA board. They are designed to be able to accept money and serve product
according to the amount of money inserted. The basic operation of VM is given below.
• The user inserts money and the money counter sends to the control unit, the amount
of money inserted in the VM by the user.
• The operation buttons are active to choose the products that people like. According
to the VM’s internal program, VM dispenses the products when people insert the
correct amount.
• If the program is designed to return the change, VM will return the change.
• When selected product is not available, VM will reject the service.
FLOW CHART FOR THE OPERATION OF SODA VENDINGMACHINE :
FORMAL DEFINITION OF THE FINITE AUTOMATA:

A DFA that describes the behaviour of a vending machine which accepts dollars and
quarters and charges $1.25 per soda. Once the machine receives at least $1.25,
corresponding to the final states, it will allow the user to select a soda. Self loops
represent ignored input. The machine will not dispense a soda until at least $1.25 has
been deposited and it will not accept more money once it has already received greater
than or equal to $1.25.

Formal definition of the DFA can be written as

D = (Q, 𝚺, δ, q0, F)
where
• Q → set of states {$0.00, $0.25, $0.50, $0.75, $1.00, $1.25, $1.50, $1.75, $2.00}
• 𝚺 → input alphabet {$0.25, $1.00, select}
• q0 → initial state. $0.00
• F → set of final states
• δ → transition function which is shown below as transition diagram

Transition Diagram :

RESULT:

The conceptual model of the vending machine is studied using FSM automata theory.
Constructing a FSM which uses fewer states enables the machine to provide fast
response serving.
EXP NO : 8(D)
DATE :

NATURAL LANGUAGE PROCESSING

AIM: To study and understand the formal design, specification and modelling of Natural
Language Processing using Automata Theory

NATURAL LANGUAGE PROCESSING (NLP) :

Natural language processing is a field of linguistics and computer science which focuses
on processing natural language. Natural languages are human spoken languages like
English, Telugu and Tamil, in opposition to artificial languages such computer languages
C or Java. The main goal of NLP is to make human languages automatically processable.
It implies finding techniques to convert an utterance which can be either spoken or
written into formal data. Formal data are a representation of that utterance that can be
processed using a computer and with no or minimal supervision. Some part of natural
language processing relies on automata theory.

FINITE AUTOMATA FOR SIMPLE STRUCTURES :

Automata for Recognizing Dates :

Suppose we want to recognize dates (just day and month pairs) written in the format
day/month. The day and the month may be expressed as one or two digits (e.g. 11/2,
1/12 etc.). This format corresponds to the following simple FSA, where each character
corresponds to one transition:

This is a NFA. For example, an input starting with the digit 3 will move the FSA to both
state 2 and state 3.

Suppose we want to recognize a comma-separated list of such dates, the FSA can be
designed as shown below. It has a cycle and can accept a sequence of indefinite length.
Lexicon :

In linguistics, a lexicon is the vocabulary of a person, group or language. It contains all

the minimal grammatical elements of a language. Sample lexicon for the word do and
some of its derivatives is shown below:
do
did
does
done
Efficient representation of lexicons are possible using finite state automata as shown
below.

Constructing a Deterministic Finite Automata can improve the access and minimizing
the automata can reduce the number of states considerably.

Can Finite Automata model the syntax of natural languages?

The syntax of natural languages cannot be described by Finite Automata. Strings having
infinite recursion cannot be generated by a FSM. However, FSMs are very useful for
partial grammars which don’t require full recursion. For representing complex
structures, context free grammars are useful.
CONTEXT FREE GRAMMARS :

In formal language theory, context-free grammar (CFG) is a certain type of formal

grammar. A set of production rules that describe all possible strings in a given formal
language. Languages generated by context-free grammars are known as context-free
languages.

CFGs arise in linguistics where they are used to describe the structure of sentences and
words in a natural language, and they were in fact invented by the linguist Noam
Chomsky for this purpose.

In computer science, as the use of recursively-defined concepts increased, they are used
more and more. In an early application, grammars are used to describe the structure of
programming languages. In a newer application, they are used in an essential part of
the Extensible Markup Language (XML) called the Document Type Definition.

A CFG has four components:

1. A set of non-terminals
2. A set of terminals
3. A set of rules (productions)
4. A start symbol

A Simple CFG for a fragment of English

S -> NP VP
VP -> VP PP
VP -> V
VP -> V NP
VP -> V VP
NP -> NP PP
PP -> P NP
;;; lexicon
V -> can
V -> fish
NP -> fish
NP -> rivers
NP -> pools
NP -> December
NP -> Scotland
NP -> it
NP -> they
P -> in
The rules with terminal symbols on the RHS correspond to the lexicon. Here are some
strings which the grammar generates, along with their bracketings:

they fish
(S (NP they) (VP (V fish)))

they can fish

(S (NP they) (VP (V can) (VP (V fish))))

they fish in rivers

(S (NP they) (VP (VP (V fish)) (PP (P in) (NP rivers))))

they fish in rivers in December

(S (NP they) (VP (VP (V fish)) (PP (P in) (NP (NP rivers) (PP (P in) (NP December))))))

Parse Tree

A CFG only defines a language. It does not say how to determine whether a given string
belongs to the language it defines. To do this, a parser can be used whose task is to map
a string of words to its parse tree. A parse tree or derivation tree is an ordered, rooted
tree that represents the syntactic structure of a string according to some context-free
grammar.

RESULT:

The application of finite automata and Context Free Grammars in the field of natural
language processing is studied.