编译原理作业1,2

最新推荐文章于 2024-05-13 22:41:44 发布
原创 最新推荐文章于 2024-05-13 22:41:44 发布 · 497 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一种使用C++实现确定有限自动机（DFA）与非确定有限自动机（NFA）之间的转换方法，并进一步实现了DFA的最小化。通过具体的代码示例展示了如何构造DFA和NFA，以及如何将NFA转换为DFA并进行最小化处理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

12.14修改： 实验一换一种更靠谱的dfa并且修改了空格问题
先贴实验一二，这两天写的吐血
实验一：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define sz(X) ((int)X.size())

//32-126
map<string, string> mp;
char sep[] = "+-*=/&|!><:;,(){} ";
char ans[][10] = {"","str","ch","num"};
int seple = strlen(sep);
struct Node{
    int to,nx; char di; int ty;
}E[1000];
int head[100], tot;
void add(int u, int v, char w, int type) {
    E[tot].to = v; E[tot].nx = head[u]; E[tot].di = w; E[tot].ty = type; head[u] = tot++;
}
void make1(int x, int ty) {
    for(int i = 0; i < seple-1; ++i) {
        add(x, 8, sep[i], ty);
    }
    add(x, 0, ' ', ty);
}
char s[105];
void solve() {
    int len = strlen(s); s[len] = ' ';
    int x = 0;
    string tt; tt.clear();
    for(int i = 0; i <= len; ++i) {
        int fl = 0;
    //   printf("%d %c ",x,s[i]); cout << tt << endl;
        for(int j = head[x]; ~j; j = E[j].nx) {
            int y = E[j].to; char z = E[j].di; int type = E[j].ty;
            if(z == s[i]) {
            //    printf("%d %d %c\n",x,y,z);
                x = y;
                fl = 1;
                if(!type && s[i] != ' ') tt += s[i];
                else {
                    if(!tt.empty()) {
                        if(type == 1) {
                            cout << tt << " str" << endl;
                        }else if(type == 2) {
                            cout << tt << " ch" << endl;
                        }else if(type == 3) {
                            cout << tt << " num" << endl;
                        }else if(type == 4) {
                            i--;
                            for(int k = 0; k < tt.length(); ++k) {
                                if(k+1 < tt.length()) {
                                    string tmp; tmp.clear(); tmp += tt[k]; tmp += tt[k+1];
                                    string tmp2; tmp2 += tt[k];
                                    if(mp.count(tmp)) {
                                        cout << tmp << ' ' << mp[tmp] << endl; k++;
                                    }else if(mp.count(tmp2)) {
                                        cout << tmp2 << ' ' << mp[tmp2] << endl;
                                    }else {
                                        fl = 0; goto li;
                                    }
                                }else {
                                    string tmp2; tmp2 += tt[k];
                                    if(mp.count(tmp2)) {
                                        cout << tmp2 << ' ' << mp[tmp2] << endl;
                                    }else {
                                        fl = 0; goto li;
                                    }
                                }
                            }
                        }
                        else {
                            if(mp.count(tt)) {
                                cout << tt  << ' ' << mp[tt] << endl;
                            }else cout << tt << ' ' << "id" << endl;
                        }
                    }
                    tt.clear();
                    if(s[i] != ' ' && type != 4) tt += s[i];
                }
                break;
            }
        }
        li: if(!fl) {
            printf("There is a error\n"); break;
        }
    }
}
int main() {
    mp["int"] = "kw_int"; mp["char"] = "kw_char"; mp["void"] = "kw_void"; mp["if"] = "kw_if"; mp["else"] = "kw_else";
    mp["switch"] = "kw_switch"; mp["case"] = "kw_case"; mp["default"] = "kw_default"; mp["while"] = "kw_while"; mp["do"] = "kw_do";
    mp["for"] = "kw_for"; mp["break"] = "kw_break"; mp["continue"] = "kw_continue"; mp["return"] = "kw_return";
    mp["+"] = "add"; mp["-"] = "sub"; mp["*"] = "mul"; mp["/"] = "div"; mp["%"] = "mod"; mp["++"] = "inc"; mp["--"] = "dec"; mp["!"] = "not";
    mp["&&"] = "and"; mp["||"] = "or"; mp["="] = "assign"; mp[">"] = "gt"; mp[">="] = "ge"; mp["<"] = "lt"; mp["<="] = "le"; mp["=="] = "equ"; mp["!="] = "nequ";
    mp[","] = "comma"; mp[":"] = "colon"; mp[";"] = "simcon"; mp["("] = "lparen"; mp[")"] = "rparen"; mp["{"] ="lbrac"; mp["}"] = "rbrac";
    tot = 0;
    memset(head,-1,sizeof(head));
    add(0, 0, ' ', 0);

    add(0, 1, '\"', 0); add(1,10,'\"',0);
    for(int i = 32; i <= 126; ++i) {
        if(i != '\"') add(1,1,i,0);
    }
    make1(10,1);

    add(0, 2, '\'', 0);
    for(int i = 32; i <= 126; ++i) {
        if(i != '\\') add(2, 3, i, 0);
    }
    add(2, 11, '\\', 0); add(11, 3, '\'', 0); add(11, 3, '\"', 0);
    add(3, 9, '\'', 0);
    make1(9,2);

    for(int i = 1; i <= 9; ++i) add(0, 5, i+'0', 0);
    for(int i = 0; i <= 9; ++i) add(5, 5, i+'0', 0);
    make1(5, 3);

    add(0, 6, '0', 0); make1(6, 3);
    for(int i = 0; i <= 9; ++i) add(6, 12, i+'0', 0);
    for(int i = 0; i <= 9; ++i) add(12,12, i+'0', 0);
    make1(12, 3);

    add(6,7, 'X',0);
    for(int i = 0; i <= 9; ++i) add(7, 7, i+'0', 0);
    for(int i = 'A'; i <= 'Z'; ++i) add(7,7, i, 0);
    make1(7, 3);

    for(int i = 0; i < seple-1; ++i) add(0,8,sep[i],0);
    for(int i = 0; i < seple-1; ++i) add(8,8,sep[i],0);
    for(int i = 32; i <= 126; ++i) {
        int fl = 1;
        for(int j = 0; j < seple-1; ++j) {
            if(i == sep[j]) {
                fl = 0; break;
            }
        }
        if(fl) add(8, 0, i, 4);
    }

    for(int i = 'a', j = 'A'; i <= 'z'; ++i, ++j) {
            add(0,13,i,0); add(0,13,j,0);
    } add(0, 13, '_', 0);
    for(int i = 'a', j = 'A'; i <= 'z'; ++i, ++j) {
            add(13,13,i,0); add(13,13,j,0);
    } add(13, 13, '_', 0);
    for(int i = 0; i <= 9; ++i) add(13,13,'0'+i,0);
    make1(13, 5);

    while(gets(s)) {
        solve();
    }
    return 0;
}

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

map<string, string> mp;
char s[1005];

void doo(string S) {
    string ans;
    for(int i = 0; i < S.length(); ++i) {
        if(s[i] >= '0' && s[i] <= '9') ans = "num";
        else if(s[i] == '\'') ans = "ch";
        else if(s[i] == '\"') ans = "str";
        else if(mp.count(S)) ans = mp[S];
        else ans = "id";
    }
    cout << S <<' '<< ans << endl;
}
int main() {
  //  freopen("in.txt","r",stdin);
    mp["int"] = "kw_int"; mp["char"] = "kw_char"; mp["void"] = "kw_void"; mp["if"] = "kw_if"; mp["else"] = "kw_else";
    mp["switch"] = "kw_switch"; mp["case"] = "kw_case"; mp["default"] = "kw_default"; mp["kw_while"] = "while"; mp["do"] = "kw_do";
    mp["for"] = "kw_for"; mp["break"] = "kw_break"; mp["continue"] = "kw_continue"; mp["return"] = "kw_return";
    mp["+"] = "add"; mp["-"] = "sub"; mp["*"] = "mul"; mp["/"] = "div"; mp["%"] = "mod"; mp["++"] = "inc"; mp["--"] = "dec"; mp["!"] = "not";
    mp["&&"] = "and"; mp["||"] = "or"; mp["="] = "assign"; mp[">"] = "gt"; mp[">="] = "ge"; mp["<"] = "lt"; mp["<="] = "le"; mp["=="] = "equ"; mp["!="] = "nequ";
    mp[","] = "comma"; mp[":"] = "colon"; mp[";"] = "simcon"; mp["("] = "lparen"; mp[")"] = "rparen"; mp["{"] ="lbrac"; mp["}"] = "rbrac";
    while(gets(s)) {
        int n = strlen(s);
        s[n] = ' ';
        string tt;
        for(int i = 0; i <= n; ++i) {
            if(s[i] == ' ') {
                if(!tt.empty()) {
                    doo(tt);
                    tt.clear();
                }
            }else tt += s[i];
        }
    }
    return 0;
}

实验二

#include<bits/stdc++.h>
using namespace std;
#define sz(X) ((int)X.size())
const int INF = 0x3f3f3f3f;
const int N = 30;

int n, m;
struct Node{
    int to, nx;
    char di;
}E[N*N];
int head[N], tot;
void add(int u, int v, char w) {
    E[tot].to = v; E[tot].nx = head[u]; E[tot].di = w; head[u] = tot++;
}
int tmp;
void Find(int x) {
    for(int i = head[x]; ~i; i = E[i].nx) {
        int y = E[i].to; char z = E[i].di;
        if(z == '~' && !(tmp>>y&1) ) {
            tmp |= 1<<y; Find(y);
        }
    }
}

char stchar[N];
map<char, int> charst; int cc;

map<int, int> vis; int vc_cn;
vector<pair<int,int> > vc[N];
int deep[N]; int mp_cn; int type[N];

struct Tode{
    int fr,to,di;
    Tode(int a=0, int b=0, int c=0):fr(a), to(b), di(c){};
    bool operator < (const Tode &T) const {
        if(fr != T.fr) return fr < T.fr;
        else if(to != T.to) return to < T.to;
        else return di < T.di;
    }
};
vector<Tode> F;
void show(int x) {
    for(int i = 0; i < vc_cn; ++i) {
        if(x>>i&1) printf("%d ",i);
    }
    printf("\n");
}

int f[N];
int find(int x) { return x==f[x]? x : f[x] = find(f[x]); }
void dfs(int x) {
 //   show(x);
    int ch[N][N]; int ch_cn = 0; memset(ch,-1,sizeof(ch));
    for(int i = 0; i < vc_cn; ++i) f[i] = i;
    for(int i = 0; i < vc_cn; ++i) {
        if(x>>i&1) {
            ch[++ch_cn][0] = i;
            for(int j = 0; j < sz(vc[i]); ++j) {
                int y = vc[i][j].first; int z = vc[i][j].second;
                ch[ch_cn][z] = type[y];
            }
            for(int j = 1; j < ch_cn; ++j) {
                int fl = 1;
                for(int k = 1; k <= cc; ++k) {
                    if(ch[j][k] != ch[ch_cn][k]) {
                        fl = 0; break;
                    }
                }
                if(fl) {
                    int t1 = find(ch[ch_cn][0]); int t2 = find(ch[j][0]);
                    if(t1 != t2) f[t1] = t2;
                }
            }
        }
    }
    map<int, int> num;
    map<int, int> ::iterator it;
    for(int i = 1; i <= ch_cn; ++i) {
        int t1 = find(ch[i][0]);
        if(num.find(t1) == num.end()) num[t1] = 0;
        num[t1] |= 1<<ch[i][0];
    }
    if(num.size() == 1) return;
    for(it = num.begin(); it != num.end(); ++it) {
        int t1 = it->first; int t2 = it->second;
        if(it != num.begin()) {
            for(int i = 0; i < vc_cn; ++i) {
                if(t2>>i&1) {
                    type[i] = mp_cn;
                }
            }
            mp_cn++;
        }
    }
    for(it = num.begin(); it != num.end(); ++it) {
        int t1 = it->first; int t2 = it->second;
        if(1<<t1 != t2) {
            dfs(t2);
        }
    }
}

int main(){
    int ca = 0;
    freopen("in.txt","r",stdin);
    while(~scanf("%d %d",&n,&m)) {
        tot = 0; cc = 0; vc_cn = 0; mp_cn = 0; F.clear();
        vis.clear(); charst.clear();
        for(int i = 0; i < n; ++i) scanf("%d",&deep[i]);
        memset(head,-1,sizeof(head));
        memset(type,0,sizeof(type));
        for(int i = 0; i < n; ++i) vc[i].clear();
        int edpoint = 0;
        for(int i = 1; i <= m; ++i) {
            int l,r; char d[10]; scanf("%d %d %s",&l,&r,d);
            add(l, r, d[0]);
            if( d[0] != '~' && !charst.count(d[0]) ) {
                charst[d[0]] = ++cc; stchar[cc] = d[0];
            }
        }
        for(int i = 0; i < n; ++i) if(deep[i]) edpoint |= 1<<i;
        printf("%d\n",edpoint);
    /****************NFA->DFA*************************/
        tmp = 1; Find(0);
       // show(tmp);
        queue<int> Q;
        Q.push(tmp);
        vis[tmp] = vc_cn++;
        if(tmp & edpoint) type[vc_cn-1] = 1;
        while(!Q.empty()) {
            int top = Q.front(); Q.pop();
          //  printf("::"); show(top);
            int tt[N]; memset(tt,0,sizeof(tt));
            for(int i = 0; i < n; ++i) {
                if(top>>i&1) {
                    for(int j = head[i]; ~j; j = E[j].nx) {
                        int y = E[j].to; char z = E[j].di;
                        if(z == '~') {
                            for(int k = 1; k <= cc; ++k) tt[k] |= 1<<y;
                        }else {
                            int bel = charst[z];
                            tt[bel] |= 1<<y;
                        }
                    }
                }
            }
            for(int i = 1; i <= cc; ++i) {
                if(tt[i]) {
                    tmp = 0;
                    for(int j = 0; j < n; ++j) {
                        if(tt[i]>>j&1 && !(tmp>>j&1) ) {
                            tmp |= 1<<j; Find(j);
                        }
                    }
                 //   show(tmp);
                    if(vis.find(tmp) == vis.end()) {
                        vis[tmp] = vc_cn++; Q.push(tmp);
                        if(tmp & edpoint ) type[vc_cn-1] = 1;
                    }
                    vc[vis[top]].push_back({vis[tmp],i});
                    F.push_back(Tode(vis[top],vis[tmp],i));
                    deep[vis[top]] ++;
                }
            }
        }
    /***************DFA->minDFA  0开始点1结束点 **************/
        int t1 = 0; int t2 = 0;
        for(int i = 0; i < vc_cn; ++i) {
            if(!type[i]) {
                t1 += 1<<i;
            }else {
                t2 += 1<<i;
            }
        }
        mp_cn = 2;
        dfs(t1); dfs(t2);
     //   for(int i = 0; i < vc_cn; ++i) printf("%d ",type[i]); printf("\n");
        set<Tode> has; printf("Case: %d\n",++ca);
        for(int i = 0; i < sz(F); ++i) {
            int x = F[i].fr; int y = F[i].to; int z = F[i].di;
            x = type[x]; y = type[y]; if(x == y && F[i].fr != F[i].to) continue;
            Tode tt = Tode(x,y,z);
          //  printf(":%d %d %c\n",x,y,stchar[z]);
            if(has.find(tt) == has.end()) printf("%d %d %c\n",x,y,stchar[z]);
            has.insert(tt);
        }

    }
    return 0;
}
/*
11 13
0 0 0 0 0 0 0 0 0 0 1
0 1 ~
0 7 ~
1 2 ~
1 4 ~
2 3 a
4 5 b
3 6 ~
5 6 ~
6 1 ~
6 7 ~
7 8 a
8 9 b
9 10 b
7 14
0 0 0 1 1 1 1
0 1 a
0 2 b
1 2 b
1 3 a
2 1 a
2 5 b
3 3 a
3 4 b
4 5 b
4 6 a
5 5 b
5 6 a
6 4 b
6 3 a
*/
编译原理实验报告（1和2）（可运行）.doc
08-23
实验一名称 词法分析程序（2学时） 实验目的 理解词法分析在编译程序中的作用；加深对有穷自动机模型的理解； 掌握词法分析程序的实现方法和技术。 实验内容 选择部分C语言的语法成分，设计其词法分析程序，要求能够识别关键字、运算符、分界符、标识符、常量（至少是整型常量，可以自己扩充识别其他常量）等，并能处理注释、部分复合运算符（如>=等）。单词以二元式形式输出、输出有词法错误的单词及所在行号。 实验要求 （1）待分析的简单的语法 关键字：begin if then while do end … 运算符和界符：:= + - * / < <= > >= <> = == ; ( ) # , … 其他单词是标识符id和整型常数num，通过以下正规式定义： id=l(l|d)* (l:letter d:digit) num=dd* 空格、注释：在词法分析中要去掉。 （2）各种单词符号对应的种别编码(参考这张表，可以不同) （3）待分析的源程序： (a)int main() { int a=1,b=2; b/a; /* 注释部分*/ b>a; c=a+b; cout<<c; return 0; } (b)这个待分析程序有词法错误（选做） while ((a+15)>0) { if (2x = = 7) i3=z; } 实验二名称 预测分析程序（2学时） 实验目的 掌握LL(1)文法分析思想；掌握预测分析程序的构造方法。 实验内容 设计及实现能够识别表达式的预测分析程序。 实验要求 （1）总体要求： 1) 根据文法手工或程序方式构造预测分析表； 2) 采用程序方式构造预测分析表时，需计算First()和Follow()集合，有一定难度； 3) 根据预测分析表，设计并实现预测分析总控程序，完成自上而下的语法分析器。 （2）文法的定义（可以选择此文法，也可以自己选择其他文法） （3）给出当输入串为：（i1+i2）*(i3+i4)的分析过程。（输出分析过程中的栈，输入串和利用的产生式等信息）
NFA、DFA模拟、正则表达式转NFA、NFA转DFA、DFA转正则、DFA最小化的python实现项目
m0_56745306的博客
01-25 3297
本项目基于《编译原理》第二版和《自动机理论、语言和计算导论》第三版，以及网络资料，实现包括DFA、NFA在内的多种自动机，使用python语言进行编程，以期加深对自动机的理解。
编译原理——NFA确定化和DFA最小化
热门推荐
blackier的博客
04-05 2万+
前言：这是我学习编译原理，课程实验的内容，课程早已结束，现整理发表。 一、实验任务 存储NFA与DFA； 编程实现子集构造法将NFA转换成DFA。 先完善DFA，再最小化DFA。 二、实验内容 确定NFA与DFA的存储格式。要求为3个以上测试NFA准备好相应有限自动机的存储文件。 用C或JAVA语言编写将NFA转换成DFA的子集构造法的程序。 准备3个以上测试DF...
NFA确定化及DFA最小化
一名混沌的大学生
12-13 2129
DFA确定化及NFA最小化
编译原理课设资源用于编译原理作业使用
最新发布
06-12
编译原理课程设计是计算机科学与技术专业的重要实践教学环节之一。它要求学生在理论学习的基础上，综合运用所学知识，完成从理论到实践的转化。本资源包旨在提供给学生完成编译原理课程设计所需的各类素材和工具，...
同济大学计算机系课程《编译原理》大作业项目词法分析器LR1语法分析器.zip
04-17
同济大学计算机系课程《编译原理》大作业项目词法分析器LR1语法分析器 同济大学计算机系的《编译原理》课程的大作业项目包括词法分析器和LR1语法分析器的实现。这个项目是编译原理课程中的一个重要实践环节，旨在...
华科编译原理作业
04-16
《华科编译原理》是一门深入探讨编程语言翻译机制的课程，涵盖了编译器设计的各个核心概念。以下是对部分练习题涉及知识点的详细解释： 1. **词法分析** (Chapter 101, 练习 302): 这一章节可能涉及到如何设计和...
编译原理大作业 LL(1)文法.zip
07-21
编译原理大作业 LL（1）文法实现完整代码 + 报告 ！！！ 求出能推出ε的非终结符、计算FIRST集、计算FOLLOW集、计算SELECT集、构造预测分析表、判断LL(1)文法 1. 给定无左递归和无回溯的文法，计算FIRST集合和...
2019-2020人大作业，编译原理
05-12
编译原理 本资源摘要信息主要介绍了编译原理的基础知识，包括编译程序的五个部分、语法分析、词法分析、中间代码生成、代码优化、目标代码生成等。同时还介绍了编译程序的工作过程、编译程序和解释程序的区别、语言...
编译原理复习资料...
07-15
编译原理复习资料 给出生成下述语言的三型文法： (1){an|n >=0 } (2) { anbm|n,m>=1 } (3){anbmck|n,m,k>=0 } 解：(1) S→aS|ε (2)S→aA A→aA|B B→bB|b (3)A→aA|B B→bB|C C→cC|ε
编译原理正则表达式匹配网址
10-25
Java 程序设计： 为 UnLinker.java 文件中的 UnLinker 类实现成员函数 String clean(String text)。 函数 clean 的功能是：屏蔽字符串参数 text 中的网页链接信息，并返回屏蔽后的结果； 如果无需屏蔽，则返回原来的字符串. 每个网页链接从左至右依次分成前缀，域名和后缀 三部分，各部分定义如下： 1) 前缀是以下三种情况的一种： http:// http://www. www. 2) 域名包含一个或多个字符，每个字符是一个英文字母（大小写均可） ，或者是一 个数字（0 到 9） ，或者是一个句点（.）. 3) 后缀是以下五种情况的一种： .com .org .edu .info .tv
编译原理 NFA -> DFA 确定化 + 最小化
weixin_41514525的博客
11-19 1568
测试NFA状态转换图: 当时测试的时候把把一些数据写死了，写在了一个data.txt文件里了，文件的内容是这样的; 0 1 e 0 7 e 1 2 e 1 4 e 2 3 a 4 5 b 3 6 e 5 6 e 6 7 e 7 8 a 8 9 b 9 10 b 6 1 e 源码: from tabulate import tabulate def e_closure(idx,c)...
3.2-3.3 词法分析---NFA转换到DFA~DFA 最小化 Hopcroft 算法
Tiantangbujimo7的博客
04-23 1104
子集构造算法： 因为NFA不适合直接用来做词法分析器的识别，是因为它的状态转移是不确定的，这种情况下写一个算法往往需要回溯，对于分析的效率影响会比较大，所以需要用子集构造算法由NFA将它转换成与它等价的DFA(因为DFA是确定有限状态自动机)，最终转换成词法分析器可以使用的代码。 子集构造算法思想： a(b|c)* 下图是一个NFA，很明显它的转移边包含 ε 所以它的状态转移是不确定的,我们所要做...
词法分析程序之NFA转DFA和DFA的最小化
LH is programming hard
04-17 1841
原理（1）——NFA转DFA 转化方法 我们必须知道如何将DFA转化为DFA——利用子集构造法 步骤： 为NFA添加一个开始结点和终止结点（上一节的程序本来就是这样设计） 对NFA中的结点，对开始结点做闭包，得到结点集合，以该结点集合开始，计算该集合对每一种符号的Ia、Ib 观察这些Ia、Ib在第一列是否存在？存在则不需要添加，否则添加，然后对其计算Ia、Ib，重复操作，直到所有的都已经添加过了。 对上述的结点集合重新命名，得到确定化的DFA的状态转化表。 根据该表选出代表结点，连接边，得到确定化的DFA
使用C语言实现正规表达式到自动机的转换
qq_44075108的博客
02-14 9872
正规表达式与自动机 编程完成以下功能: (1) 将一个正规表达式转换为 NFA (2) 将一个 NFA 转换为 DFA (3) 对 DFA 进行最小化 (4) 利用 DFA 判断输入的字符串是否为符合词法规则
【p10】DFA (NFA确定化) 以及DFA的最小化
夜空像是一片紫水潭，星星是些不动的大亮点，夜风是些浅蓝色的流线，云端传来喧嚣的声音。
05-13 1108
难点
NFA(子集算法,DFA最小化)代码实现
IPOmonkey的博客
11-06 4538
#include #include #include #include using namespace std; const int maxn=1001; /* NFA五元组 M={K,A,f,S,Z}; K::状态集合 A::字母表 F::转换函数 S::开始状态 Z::结束状态 */ /*状态集合K中的结点*/ string node; /*字母表A中的符号*/ string c
【编译原理实验】Lab2（二）DFA最小化
HNUCSEE的博客
11-14 5755
目录一、实验目的二、实验任务三、实验内容四、实验步骤如何存DFAHopcroft算法思想算法伪代码算法步骤算法代码运行结果 一、实验目的 学会编程实现等价划分法最小化DFA。 二、实验任务 先完善DFA，再最小化DFA。 三、实验内容 （1）准备3个以上测试DFA文件。（提示：其中一定要有没有最小化的DFA） （2）用C或C++语言编写用等价划分法最小化DFA的程序。 （3）经测试无误。测试不易。可求出两个DFA的语言集合的某个子集（如长度小于某个N），再证实两个语言集合完全相同！ 四、实验步骤 如何存DF
编译原理作业演示及参考指南
资源摘要信息:"《yufa.rar_编译原理作业》文件是关于计算机科学中编译原理这门课程的作业资源。编译原理是计算机科学与技术专业中的一门重要课程，它主要研究计算机语言翻译的理论和实现技术。编译器是将一种程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值