Ministerul Educației, Culturii și Cercetării al Republicii

Moldova
Universitatea Tehnică a Moldovei
Facultatea de Calculatoare, Informatică și Microelectronică
Departamentul „Informatică şi Ingineria Sistemelor”

REFERAT
la lucrarea de laborator nr.1
TEMA: “Gramatici regulate”
Disciplina: “LFC”

A elaborat: st. gr. MI-191, Covaliov Elina

A verificat: conf.univ.,dr.Marusic Galina

Chișinău 2020
Sarcina lucrării:

1. Pentru gramatica formală G = (VN, VT, P, S) construiţi 5 şiruri, care aparţin

limbajului L(G) generat de această gramatică. Lungimea şirului trebuie să
fie nu mai mică, decât numărul de caractere din alfabet VN+2.
2. Pentru fiecare şir să se construiască arborii de derivare.
3. Desenaţi automatul finit echivalent acestei gramatici.
4. La ce clasă al gramaticilor după Chomsky aparţine gramatica dată?

Varianta 9.
VN={S, B,D, Q },
VT={a, b, c, d } ,
P= {
1. S  aB
2. S  bB
3. B  cD
4. D  dQ
5. Q  bB
6. D  a
7. Q  dQ }

Efectuarea lucrării:

1) Construim 5 şiruri ce aparţin limbajului L(G) generat de această gramatică:

1. S->aB->acD->abdQ->acdbB->acdbcD->acdbca;

2. S->bB->bcD->bcdQ->bcdbB-> bcdbcD -> bcdbca;

3. S->aB-> acD -> acdQ -> acdbB -> acdbcD -> acdbcdQ->

acdbcdbB->acdbcdbcD->acdbcdbca;

4. S->bB-> bcD ->bcdQ -> bcdbB -> bcdbcD-> bcdbcdQ->

bcdbcdbB-> bcdbcdbcD-> bcdbcdbca;

5. S->bB-> bcD -> bccD -> bccdQ -> bccdbB -> bccdbcD ->

bccdbca;
 2) Pentru fiecare şir construim arborii de derivare:

1. 2. 3. 4. 5.
S S S S S
/\ /\ /\ /\ /\
a B b B a B b B b B
/\ /\ /\ /\ /\
c D c D c D c D c D
/\ /\ /\ /\ /\
d Q d Q d Q d Q c D
/\ /\ /\ /\ /\
b B b B b B b B d Q
/\ /\ /\ /\ /\
c D c D C D c D b B
/ / / /\ /\
a a a d Q c D
/ /\ /
b B a
/\
c D
/
a

3) Construim AF(automatul finit) echivalent acestei gramatici:

AF=(Q, , , q0, F), unde

Q – mulţimea de stări
 - vocabular
 - funcţia de tranziţie
q0 – starea iniţială
F – mulţimea stărilor finale

Algoritmul de construire AF:

1. Q = VN{X}={S, D, E, F,L, X}
2. =VT={a, b, c d }
3. q0={S}
4. F={X}
5. Pentru toate producţiile definim :
Iniţial toate mulţimile (A, b): = 0
1. S aB
(S, a): =  (S, a){B}={B}
2. D bB
(S, b): =  (S, b){B}={B}
3. B cD
(B, c): =  (B, c){D}={D}
4. D dQ
(D, d): =  (D, d){Q}={Q}
5. Q bB
(Q,b): =  (Q,b){B}={B}
6. D a
(D, a): =  (D, a){X}={X}
7. Q dQ
(Q, d): =  (Q, d){Q}={Q}

Reprezentarea grafică a AF:

a,b

X
B
c
a b

D
d
Q

3) Gramatica dată după Chomsky aparţine tipului 3, deoarece toate

producţiile date sunt de forma:
a) Aa
b) AbB
Unde a , b ∈V T şi A ,B ∈V N
Gramatica de tipul 3

P= {
1. S  aD
2. S  bA
3. B  cD
4. D  qQ
5. Q  bQ
6. Da }

Gramatica de tipul 2

P= {
1. S  addQ
2. S  bSbD
3. B  cabQ
4. D  eScq
5. Q  qBsC
6. D  ssdQ }

Gramatica de tipul 3

P= {
7. sbQSbD  sbQaDbD
8. sBqS  sBqbA
9. bbSBsdQ  bbScDsdQ
10.dqdDsQd  dqdqQsQd
11.qbDQDsD  qbDbQDsD
12.D  a }
Programul în C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int maxLetters = 10;
int minLetters = 6;
char arrow[] = {'-','>','\0'};
char lastLetter(char* s){
long length = strlen(s);
return *(s+length-1);
}
//transition S -> aB
void sMapping(char* s){
long length= strlen(s);
 *(s+length-1)='a';
*(s+length)='B';
*(s+length+1)='\0';
}
//transition S -> bB
void aLeftMapping(char* s){
long length= strlen(s);
*(s+length-1)='b';
*(s+length)='B';
*(s+length)='\0';
}
//transition B -> cD
void aRightMapping(char* s){
long length= strlen(s);
*(s+length-1)='c';
*(s+length)='D';
*(s+length+1)='\0';
}
//transition D -> dO
void bMapping (char* s){
long length= strlen(s);
*(s+length-1)='d';
*(s+length)='O';
*(s+length+1)='\0';
}
//transition Q -> bB
void cLeftMapping(char* s){
long length= strlen(s);
*(s+length-1)='b';
*(s+length)='B';
*(s+length+1)='\0';
}
//transition D -> a
void cRightMapping(char* s){
long length= strlen(s);
*(s+length-1)='a';
*(s+length)='a';
*(s+length+1)='\0';
}

void process (char* s, char* road){

long length= strlen(s);
if(length>maxLetters)
{return;}
char last=lastLetter(s);
if(last=='d'&&length>=minLetters)
{char roadToShow[100];
strcpy(roadToShow,road);
strcat(roadToShow,s);
puts(roadToShow);
return;}
else{
switch(last){
case 'S': {
sMapping(s);
char copyOfS[100];
strcpy(copyOfS,s);
strcat(copyOfS,arrow);
strcat(road,copyOfS);
process(s,road);
break;
}
case 'B': {
char copyOfS[100];
strcpy(copyOfS,s);
aLeftMapping(s);
aRightMapping(copyOfS);
process(s,road);
char buffer[100];
strcpy(buffer,copyOfS);
strcat(buffer,arrow);
strcat(road,buffer);
process(copyOfS,road);
break;
}
case 'D':{
bMapping(s);
char copyOfS[100];
strcpy(copyOfS,s);
strcat(copyOfS,arrow);
strcat(road,copyOfS);
process(s,road);
break;
}
case 'Q':{
char copyOfS[100];
strcpy(copyOfS,s);
cLeftMapping(s);
cRightMapping(copyOfS);

char roadLeftBuffer[100];
char roadRightBuffer[100];
strcpy(roadLeftBuffer,road);
strcat(roadLeftBuffer,s);
strcat(roadLeftBuffer,arrow);
strcpy(roadRightBuffer,road);
strcat(roadRightBuffer,copyOfS);
strcat(roadRightBuffer,arrow);
process(s,roadLeftBuffer);
process(copyOfS,roadRightBuffer);
break;
}
}
}
}
int main(){
char s[100];
s[0]='S';
s[1]='\0';
char road[100];
road[0]='S';
road[1]='-';
road[2]='>';
road[3]='\0';
printf("cuvintele generate sunt: \n");
process(s,road);

char vN[]= { 'S', 'B', 'D','Q','X','\0'};

printf("\nAutomatul finit echivalen gramaticii date este:\n");
printf("AF= Q,SI,RO,q,F\n");
printf("Q = Vn U {X} = {S,B,D,Q,X}\n");
printf("SI = Vt = {a,b,c,d}\n");
printf("q = S\n");
printf("F = {X}\n\n");
printf("Functiile de tranzitie sunt:\n");
if(vN[0]){
printf("1.S->aB\n RO(S,a):= RO(S,a) U {B}={B}\n\n");
}
if(vN[4]){
printf("2.D->bB\n RO(S,b):= RO(S,b) U {B}={B}\n\n");
}
if(vN[1]){
printf("3.B->cD\n RO(B,c):= RO(B,c) U {D} = {D}\n\n");
}
if(vN[2]){
printf("4.D->dQ\n RO(D,d):= RO(D,d) U {Q} = {Q}\n\n");
}
if(vN[3]){
printf("5.Q->bB\n RO(Q,b):= RO(Q,b) U {B} = {B}\n\n");
printf("6.D->a\n RO(D,a):= RO(D,a) U {X} = {X}");
}
return 1;