Write a lex program to recognize telephone operators in

Bangladesh.

%{​
#include<stdio.h>​
%}​
​
%%​
"015"[0-9]{8} {printf("Teletalk: %s\n",yytext);}​
"016"[0-9]{8} {printf("Airtel: %s\n",yytext);}​
"017"[0-9]{8} {printf("GP: %s\n",yytext);}​
"018"[0-9]{8} {printf("Robi: %s\n",yytext);}​
"019"[0-9]{8} {printf("Banglalink: %s\n",yytext);}​
.|\n​;​
%%​
​
int yywrap()​
{​
return 1;​
}​
​
int main()​
{​
yylex();​
return 0;​
}
Write a lex program to count the characters, words and lines in a
given C program.

%{​
#include <stdio.h>​
int char_count = 0, word_count = 0, line_count = 0;​
%}​
​
%%​
​
[a-zA-Z0-9_]+ { word_count++; char_count +=
yyleng; }​
\n { char_count++; line_count++; }​
. { char_count++; }​
​
%%​
​
int yywrap() {​
return 1;​
}​
​
int main() {​
yylex();​
printf("Characters: %d\nWords: %d\nLines: %d\n",
char_count, word_count, line_count);​
return 0;​
}
Write a lex program to identify integer, floating point, exponential
and complex numbers.

%{​
#include<stdio.h>​
%}​
​
%%​
[+-]?[0-9]+ {printf("Integer: %s\n",yytext);}​
[+-]?[0-9]+\.[0-9]+([eE][+-]?[0-9]+)?
{printf("Floating-Point: %s\n",yytext);}​
[+-]?[0-9]+([eE][+-]?[0-9]+)
{printf("Exponential: %s\n",yytext);}​
[+-]?[0-9]+\.[0-9]+([eE][+-]?[0-9]+)?[-+]?[0-9]+\.[0
-9]+[i] {printf("Complex: %s\n",yytext);}​
.|\n ;​
%%​
​
int yywrap()​
{​
return 1;​
}​
​
int main()​
{​
yylex();​
return 0;​
}
Write a lex program to identify and count the spaces and comments
in a given C program.

%{​
#include<stdio.h>​
int comment= 0;​
int space= 0;​
%}​
​
%%​
[ ]+ {space+=yyleng;}​
"//".* {comment++;}​
"/*"([^*]|\*+[^*/])*"*"+"/" {comment++;}​
.|\n ;​
%%​
​
int yywrap()​
{​
return 1;​
}​
​
int main()​
{​
yylex();​
printf("No of Comment: %d\n",comment);​
printf("No of Space: %d\n",space);​
return 0;​
}
Write a lex program to recognize and count all of the identifiers in a
C program

%{​
#include <stdio.h>​
#include <string.h>​
int count = 0;​
%}​
​
IDENTIFIER [a-zA-Z_][a-zA-Z0-9_]*​
KEYWORD
int|float|char|double|long|short|void|return|if|else|while|
for|do|switch|case|break|continue|struct|union|typedef​
%%​
{KEYWORD} ; // Ignore keywords​
{IDENTIFIER} {​
count++;​
printf("Identifier: %s\n", yytext);​
}​
.|\n ; // Ignore everything else​
%%​
​
int yywrap() ​
{ ​
return 1; ​
}​
​
int main() ​
{​
yylex();​
printf("\nTotal Identifiers (excluding keywords):
%d\n", count);​
return 0;​
}
Write a lex program to recognize “to be” verbs from a given
paragraph.

%{​
#include<stdio.h>​
#include<string.h>​
int count= 0;​
%}​
​
TO_BE am|is|are|was|were|been|have|has|be​
​
%%​
​
.*({TO_BE}).* {​
count++;​
printf("To-Be Verb Found: %s\n", yytext);​
}​
​
.|\n ;​
​
%%​
​
int yywrap() {​
return 1;​
}​
​
int main() {​
yylex();​
printf("Total No of To-Be Verbs: %d\n", count);​
return 0;​
}
Write a lex program to identify whether a given sentence is simple/
complex/ compound.

%{
#include <stdio.h>
#include <string.h>
%}

COMPLEX_KEYWORDS that|since|because
COMPOUND_KEYWORDS and|or|but

%%

.*({COMPLEX_KEYWORDS}).* { printf("Complex Sentence:

%s\n", yytext);}

.*({COMPOUND_KEYWORDS}).* { printf("Compound Sentence:

%s\n", yytext);}

.* { printf("Simple Sentence:
%s\n", yytext); }

.|\n ; // Ignore anything else

%%

int yywrap() {
return 1;
}

int main() {
yylex();
return 0;
}
Calculate FIRST() of the Non-Terminals.

grammar = {​
'E': ['T E1'],​
'E1': ['+ T E1', 'e'],​
'T': ['F T1'],​
'T1': ['* F T1', 'e'],​
'F': ['( E )', 'i']​
}
​
first= {}
​
for symbol in grammar:​
first[symbol]= set()​
def get_first(symbol):​
if symbol not in grammar:​
return {symbol}​
if first[symbol]:​
return first[symbol]​
result= set()​
for rule in grammar[symbol]:​
parts= rule.split()​
for part in parts:​
part_first= get_first(part)​
result.update(part_first -{'e'})​
if 'e' not in part_first:​
break​
else:​
result.add('e')
​
first[symbol]= result​
return result​
​
for symbol in grammar:​
get_first(symbol)
​
print("FIRST SETS:\n")​
for symbol in sorted(first):​
if symbol in grammar or symbol=='e':​
print(f"{symbol} : {first[symbol]}")
Ambiguity

from nltk import CFG, ChartParser​

import re​
​
def get_input():​
rules= []​
while True:​
line= input().strip()​
if line.upper() == "END":​
break​
rules.append(line)​
return rules​
​
def is_ambiguous(cfg_text, test_string):​
cfg= CFG.fromstring("\n".join(cfg_text))​
parser= ChartParser(cfg)

trees= list(parser.parse(test_string.split()))​
​
if len(trees) > 1:​
print("CFG is ambiguous")​
return True​
else:​
print("CFG is unambiguous")​
return False​
​
def remove_left_recursion(rules):​
new_rules= []​
grammar_dict= {}​
for rule in rules:​
head, productions= rule.split("->")​
head= head.strip()​
productions= productions.split("|")​
productions= [production.strip() for production in productions]​
grammar_dict[head]= productions​
​
for non_ter in list(grammar_dict.keys()):​
alpha= []​
beta= []
 for production in grammar_dict[non_ter]:​
if production[0] == non_ter:

alpha.append(production[3:].strip())​
else:​
beta.append(production)​
​
if alpha:​
new_non_term= non_ter + "'"​
while new_non_term in grammar_dict:​
new_non_term += "'"​
​
new_beta_productions= [b + " " + new_non_term for b in beta]​
new_alpha_productions= [a + " " + new_non_term for a in alpha]​
grammar_dict[non_ter]= new_beta_productions​
grammar_dict[new_non_term]= new_alpha_productions + ["E"]​
for non_ter in list(grammar_dict.keys()):​
new_rule= non_ter + "->" + "|".join(grammar_dict[non_ter])​
new_rules.append(new_rule)​
return new_rules​
user_cfg= get_input()​
test_string= input("\nEnter test string: ").strip()​
if is_ambiguous(user_cfg, test_string):​
print("Remove Left Recursion")​
fixed_cfg= remove_left_recursion(user_cfg)​
print("\nNew Rules:")​
for rule in fixed_cfg:​
print(rule)
FIRST AND FOLLOW:
def compute_first_sets(grammar):​
first = {nt: set() for nt in grammar}​
​
def first_of(symbol):​
if symbol not in grammar:​
return {symbol} # Terminal​
if first[symbol]: # Already computed​
return first[symbol]​
​
for rule in grammar[symbol]:​
for part in rule:​
part_first = first_of(part)​
first[symbol].update(part_first - {'ε'})​
if 'ε' not in part_first:​
break​
else:​
first[symbol].add('ε') # All parts can go to ε​
return first[symbol]​
​
for nt in grammar:​
first_of(nt)​
​
return first​
​
​
def compute_follow_sets(grammar, first_sets, start_symbol):​
follow = {nt: set() for nt in grammar}​
follow[start_symbol].add('$') # Rule 1: Add $ to FOLLOW(start)​
​
while True:​
updated = False​
for head in grammar:​
for rule in grammar[head]:​
trailer = follow[head].copy()​
for symbol in reversed(rule):​
if symbol in grammar: # Non-terminal​
before = len(follow[symbol])​
follow[symbol].update(trailer)​
 if 'ε' in first_sets[symbol]:​
trailer.update(first_sets[symbol] -
{'ε'})​
else:​
trailer = first_sets[symbol]​
if len(follow[symbol]) > before:​
updated = True​
else: # Terminal​
trailer = {symbol}​
if not updated:​
break​
​
return follow​
​
​
# === Example Grammar ===​
grammar = {​
'E': [['T', "E'"]],​
"E'": [['+', 'T', "E'"], ['ε']],​
'T': [['F', "T'"]],​
"T'": [['*', 'F', "T'"], ['ε']],​
'F': [['(', 'E', ')'], ['id']]​
}​
​
# === Compute Sets ===​
first_sets = compute_first_sets(grammar)​
follow_sets = compute_follow_sets(grammar, first_sets, 'E')​
​
# === Print FIRST sets ===​
print("FIRST Sets:")​
for nt in first_sets:​
print(f"FIRST({nt}) = {{ {', '.join(sorted(first_sets[nt]))} }}")​
​
# === Print FOLLOW sets ===​
print("\nFOLLOW Sets:")​
for nt in follow_sets:​
print(f"FOLLOW({nt}) = {{ {', '.join(sorted(follow_sets[nt]))}
}}")​
Left Recursion:
grammar = {
'E': ['E + T', 'T'],
'T': ['T * F', 'F'],
'F': ['( E )', 'id']
}

for nt in grammar:
for prod in grammar[nt]:
if prod.split()[0] == nt:
print(f"Left recursion in {nt} -> {prod}")
break
else:
print(f"No left recursion in {nt}")

Ambiguity:
import nltk
from nltk import CFG
from nltk.parse.chart import ChartParser
grammar = CFG.fromstring("""
S -> S '+' S
| S '*' S
| 'id'
""")

user_input = input("Enter a space-separated sentence using 'id', '+', '*':\n").strip()

tokens = user_input.split()

parser = ChartParser(grammar)
trees = list(parser.parse(tokens))

# Show results
if trees:
✅
print(f"\n Number of parse trees: {len(trees)}")

⚠️
if len(trees) > 1:
print(" Ambiguity Detected!\n")
else:
✅
print(" No ambiguity detected.\n")