Scribd
Upload
6 views11 pages

Piyush 14937

Uploaded by

Piyush Agrahari
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
6 views11 pages

Piyush 14937

Uploaded by

Piyush Agrahari
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 11

1.

Write a program to
simulate an FA that accepts

a. Union of the languages L1


and L2
#include<bits/stdc++.h>
using namespace std;
//code by PIYUSH
struct PairHash {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& pair) const {
return hash<T1>()(pair.first) ^ hash<T2>()(pair.second);
}
};
class DFA {
private:
int startState;
unordered_set<int> acceptedStates;
unordered_map<int, unordered_map<char, int>>
transitions;

public:
DFA(int startState) : startState(startState) {}

void addAcceptState(int state) {


acceptedStates.insert(state);
}
void addTransition(int fromState, char symbol, int toState) {
transitions[fromState][symbol] = toState;
}

int getStartState() const {


return startState;
}

bool isAcceptedState(int state) const {


return acceptedStates.count(state) > 0;
}

int getTransition(int state, char symbol) const {


if (transitions.count(state) &&
transitions.at(state).count(symbol)) {
return transitions.at(state).at(symbol);
}
return -1;
}
};

DFA unionDFA(const DFA& dfa1, const DFA& dfa2) {


DFA result(0);
queue<pair<int, int>> toProcess;
unordered_set<pair<int, int>,PairHash> visited;
unordered_map<pair<int, int>, int,PairHash> stateMapping;
int nextState = 1;

toProcess.push({dfa1.getStartState(), dfa2.getStartState()});
visited.insert({dfa1.getStartState(), dfa2.getStartState()});
stateMapping[{dfa1.getStartState(), dfa2.getStartState()}] = 0;

while (!toProcess.empty()) {
auto [state1, state2] = toProcess.front();
toProcess.pop();
int combinedState = stateMapping[{state1, state2}];

if (dfa1.isAcceptedState(state1) ||
dfa2.isAcceptedState(state2)) {
result.addAcceptState(combinedState);
}

for (char symbol = 'a'; symbol <= 'z'; ++symbol) {


int nextState1 = dfa1.getTransition(state1, symbol);
int nextState2 = dfa2.getTransition(state2, symbol);

pair<int, int> nextCombinedState = {nextState1,


nextState2};

if (nextState1 != -1 || nextState2 != -1) {


if (stateMapping.find(nextCombinedState) ==
stateMapping.end()) {
stateMapping[nextCombinedState] = nextState++;
}

result.addTransition(combinedState, symbol,
stateMapping[nextCombinedState]);

if (visited.find(nextCombinedState) == visited.end()) {
visited.insert(nextCombinedState);
toProcess.push(nextCombinedState);
}
}
}
}
return result;
}

bool simulateDFA(const DFA& dfa, const string& input) {


int currentState = dfa.getStartState();

for (char symbol : input) {


currentState = dfa.getTransition(currentState, symbol);
if (currentState == -1) {
return false;
}
}
return dfa.isAcceptedState(currentState);
}
int main()
{
DFA dfa1(0);
dfa1.addAcceptState(2);
dfa1.addTransition(0,'a',1);
dfa1.addTransition(1,'b',2);

DFA dfa2(0);
dfa2.addAcceptState(2);
dfa2.addTransition(0,'a',1);
dfa2.addTransition(1,'a',2);

DFA unionResult = unionDFA(dfa1,dfa2);

string input;
cout<<"Enter input string : ";
cin>>input;

if(simulateDFA(unionResult,input)){
cout<<"STRING IS ACCEPTED";
}else{
cout<<"STRING IS REJECTED";
}

return 0;
}

b. Intersection of the
languages L1 and L2

#include<bits/stdc++.h>
using namespace std;

// Code by PIYUSH

struct pair_hash {
template <class T1, class T2>
std::size_t operator()(const std::pair<T1, T2>& p) const {
return std::hash<T1>()(p.first) ^ (std::hash<T2>()(p.second)
<< 1);
}
};

class DFA {
private:
int startState;
unordered_set<int> acceptStates;
unordered_map<int, unordered_map<char, int>> transitions;

public:
DFA(int startState) : startState(startState) {}
void addAcceptState(int state) {
acceptStates.insert(state);
}

void addTransition(int fromState, char symbol, int toState) {


transitions[fromState][symbol] = toState;
}

int getStartState() const {


return startState;
}

bool isAcceptState(int state) const {


return acceptStates.count(state) > 0;
}

int getTransition(int state, char symbol) const {


if (transitions.count(state) &&
transitions.at(state).count(symbol)) {
return transitions.at(state).at(symbol);
}
return -1;
}
};

DFA intersectDFA(const DFA& dfa1, const DFA& dfa2) {


using StatePair = pair<int, int>;
DFA result(0);

queue<StatePair> toProcess;
unordered_map<StatePair, int, pair_hash> stateMapping;
int stateCounter = 0;

toProcess.push({dfa1.getStartState(), dfa2.getStartState()});
stateMapping[{dfa1.getStartState(), dfa2.getStartState()}] =
stateCounter++;

while (!toProcess.empty()) {
auto [state1, state2] = toProcess.front();
toProcess.pop();
int combinedState = stateMapping[{state1, state2}];

if (dfa1.isAcceptState(state1) && dfa2.isAcceptState(state2))


{
result.addAcceptState(combinedState);
}

for (char symbol = 'a'; symbol <= 'z'; ++symbol) {


int nextState1 = dfa1.getTransition(state1, symbol);
int nextState2 = dfa2.getTransition(state2, symbol);

if (nextState1 != -1 && nextState2 != -1) {


StatePair nextCombinedState = {nextState1,
nextState2};

if (stateMapping.find(nextCombinedState) ==
stateMapping.end()) {
stateMapping[nextCombinedState] = stateCounter++;
toProcess.push(nextCombinedState);
}

result.addTransition(combinedState, symbol,
stateMapping[nextCombinedState]);
}
}
}
return result;
}

bool simulateDFA(const DFA& dfa, const string& input) {


int currentState = dfa.getStartState();

for (char symbol : input) {


currentState = dfa.getTransition(currentState, symbol);
if (currentState == -1) {
return false;
}
}
return dfa.isAcceptState(currentState);
}

int main() {
DFA dfa1(0);
dfa1.addAcceptState(2);
dfa1.addTransition(0, 'a', 1);
dfa1.addTransition(1, 'b', 2);

DFA dfa2(0);
dfa2.addAcceptState(2);
dfa2.addTransition(0, 'a', 1);
dfa2.addTransition(1, 'a', 2);

DFA intersectionDFAResult = intersectDFA(dfa1, dfa2);

string input;
cout << "Enter input string: ";
cin >> input;

if (simulateDFA(intersectionDFAResult, input))
cout << "STRING IS ACCEPTED" << endl;
else
cout << "STRING IS REJECTED" << endl;

return 0;
}

You might also like