1.1可能答案

最新推荐文章于 2022-07-02 17:46:51 发布
最新推荐文章于 2022-07-02 17:46:51 发布
阅读量2.1k 收藏 2
点赞数
分类专栏： 编译原理
练习的可能答案
练习1.1.1 编译器和解释器之间的区别是什么？
编译器和解释器同为语言处理器，但仅从字面上就能发现较大的区别。编译器主要就是将一种语言翻译成另一种语言的工具，而解释器更主要的在于解释用户的行为。
练习1.1.2 编译器相对于解释器的优点是什么？解释器相对于编译器的有点是什么？
编译器生成的目标程序通常比解释器快很多，但是解释器的错误诊断效果比编译器更好，因为它逐个语句地执行源程序。
练习1.1.3 在一个语言处理系统中，编译器产生汇编语言而不是机器语言的好处是什么？
就如书中写到的“汇编语言比较容易调试和输出”，这样就减轻了编译器设计的工作量，将部分工作转到汇编器上，是的设计更专注与编译器本身，尽量减少超出其本身所容纳的内容的范围。
练习1.1.4 把一种高级语言翻译成为另一种高级语言的编译器称为（source-to-source）的翻译器。编译器使用C语言作为目标语言有什么好处？
就好比为什么编译器要产生汇编语言而是不是机器语言一样，C语言更简单更常用更加容易理解，同样方便调试和输出。
练习1.1.5 描述一下汇编器所要完成的一些任务。
汇编器就类似与编译器，只是它的源语言不是高级语言而是汇编语言。同样，它需要一个预处理器进行预处理，如聚合文件，展开宏等。写成的机器语言也要类似与连接器和加载器的程序，完成类似的工作。
HADES_谭
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《编译原理》课后习题答案
10-24
《编译原理》课后习题答案第一章 第 1 章引论 第 1 题 解释下列术语： （1）编译程序 （2）源程序 （3）目标程序 （4）编译程序的前端 （5）后端 （6）遍 答案： （1） 编译程序：如果源语言为高级语言，目标语言为某台计算机上的汇编语言或机器语 言，则此翻译程序称为编译程序。 （2） 源程序：源语言编写的程序称为源程序。 （3） 目标程序：目标语言书写的程序称为目标程序。 （4） 编译程序的前端：它由这样一些阶段组成：这些阶段的工作主要依赖于源语言而与 目标机无关。通常前端包括词法分析、语法分析、语义分析和中间代码生成这些阶 段，某些优化工作也可在前端做，也包括与前端每个阶段相关的出错处理工作和符 号表管理等工作。 （5） 后端：指那些依赖于目标机而一般不依赖源语言，只与中间代码有关的那些阶段， 即目标代码生成，以及相关出错处理和符号表操作。 （6） 遍：是对源程序或其等价的中间语言程序从头到尾扫视并完成规定任务的过程。 第 2 题 一个典型的编译程序通常由哪些部分组成？各部分的主要功能是什么？并画出编译程 序的总体结构图。 答案： 一个典型的编译程序通常包含 8 个组成部分，它们是词法分析程序、语法分析程序、语 义分析程序、中间代码生成程序、中间代码优化程序、目标代码生成程序、表格管理程序和 错误处理程序。其各部分的主要功能简述如下。 词法分析程序：输人源程序，拼单词、检查单词和分析单词，输出单词的机内表达形式。 语法分析程序：检查源程序中存在的形式语法错误，输出错误处理信息。 语义分析程序：进行语义检查和分析语义信息，并把分析的结果保存到各类语义信息表 中。 中间代码生成程序：按照语义规则，将语法分析程序分析出的语法单位转换成一定形式 的中间语言代码，如三元式或四元式。 中间代码优化程序：为了产生高质量的目标代码，对中间代码进行等价变换处理。 盛威网（www.snwei.com）专业的计算机学习网站1 《编译原理》课后习题答案第一章 目标代码生成程序：将优化后的中间代码程序转换成目标代码程序。 表格管理程序：负责建立、填写和查找等一系列表格工作。表格的作用是记录源程序的 各类信息和编译各阶段的进展情况，编译的每个阶段所需信息多数都从表格中读取，产生的 中间结果都记录在相应的表格中。可以说整个编译过程就是造表、查表的工作过程。需要指 出的是，这里的“表格管理程序”并不意味着它就是一个独立的表格管理模块，而是指编译 程序具有的表格管理功能。 错误处理程序：处理和校正源程序中存在的词法、语法和语义错误。当编译程序发现源 程序中的错误时，错误处理程序负责报告出错的位置和错误性质等信息，同时对发现的错误 进行适当的校正（修复），目的是使编译程序能够继续向下进行分析和处理。 注意：如果问编译程序有哪些主要构成成分，只要回答六部分就可以。如果搞不清楚， 就回答八部分。 第 3 题 何谓翻译程序、编译程序和解释程序？它们三者之间有何种关系？ 答案： 翻译程序是指将用某种语言编写的程序转换成另一种语言形式的程序的程序，如编译程 序和汇编程序等。 编译程序是把用高级语言编写的源程序转换（加工）成与之等价的另一种用低级语言编 写的目标程序的翻译程序。 解释程序是解释、执行高级语言源程序的程序。解释方式一般分为两种：一种方式是， 源程序功能的实现完全由解释程序承担和完成，即每读出源程序的一条语句的第一个单词， 则依据这个单词把控制转移到实现这条语句功能的程序部分，该部分负责完成这条语句的功 能的实现，完成后返回到解释程序的总控部分再读人下一条语句继续进行解释、执行，如此 反复；另一种方式是，一边翻译一边执行，即每读出源程序的一条语句，解释程序就将其翻 译成一段机器指令并执行之，然后再读人下一条语句继续进行解释、执行，如此反复。无论
编译原理之路（一）第一章典型习题解答
小松与蘑菇
02-28 2370
第一章没啥好讲，就做几道典型题好了…… 1.1部分 1.编译器和解释器之间的区别是什么？ 分 编译器 解释器 实现机理 将程序翻译成一种能够被计算机执行的形式 利用用户提供的输入执行源程序中指定的操作 实现路径 源程序->编译器->目标程序 源程序+输入）->解释器-&a
编译器和解释器
xc123555的博客
07-02 8590
编译器和解释器的区别： 解释器：直接执行用编程语言编写的指令程序。 编译器：把源代码转换成(翻译)低级语言的程序。 1、解释器是直接执行用编程语言编写的指令程序，而编译器是把与源码转换即翻译低级语言的程序 ，解释器直接利用用户提供的输入执行源程序中指定的操作。 2、编译器生成一个独立的程序，而解释的程序总是需要解释器来运行 解释器的优点是比较容易让用户实现自己跨平台的代码，比如java,php等，同一套代码可以几乎在所有的操作系统
龙书《编译原理》第一章学习答案
weixin_50513260的博客
02-18 920
1.1.1 编译器和解释器之间的区别是什么？ 编译器阅读源语言编写的程序（源程序），并把该程序编译成一个等价的目标语言编写的程序（目标程序）；（编译结束后执行） 解释器直接利用用户提供的输入执行源程序中指定的操作（边解释边执行）。 1.1.2 编译器相对于解释器的优点是什么？解释器相对于编译器的优点是什么？ 由于解释器是边解释边执行，而编译器是将源程序编译成目标程序后再执行，所以在把用户输入映射成为输出的过程中，编译器产生目标程序的速度快很多，解释器逐句执行所以诊断效果更好。 1.1.3 在一个语言系
【编译原理】龙书第三章作业答案
热门推荐
作业报告杂物间
01-17 2万+
【编译原理】龙书第三章作业答案 练习3.1.1：根据3.1.2节中的讨论，将下面的C++程序划分成正确的词素序列。哪些词素应该有相关联的词法值？应该具有什么值？ 答案： 左列为词素，右列为值，划分如下： < float> 值为它本身 <id，limitedSquare> 值为*limitedSquare指针 <(> 标点符号无值 ...
windows_sudoku_1.1_release
03-07
完成生成，显示，保存，功能，等功能，详情请见头文件内所有详细注释,1.1版本开始支持逆向计算，凡是正常生成的矩阵都是有具体参考，答案，由于可能根据你的设置不同，答案不唯一，但是会有个系统标准答案，谢谢
小怪兽音效 v1.1
10-29
声音输出通道选择第一次打开软件可能会没有声音，请选择一下声音输出通道4.互动游戏系列互动游戏系列比较适合电脑主播.我自己的想法是通过转播的方式使用。举例YY直播上（别人给刷一组66）那么就替他买一个爱心，...
工程伦理课后习题答案1
08-08
第一章1.1 结合工程活动的特点，思考为什么在工程实践中会出现伦理问题？工程活动的特点：1）工程活动蕴含着有意识、有目的的设计。在具体实施之前，工程师需要明确工
网络安全员题库答案解析.xls
12-28
网络安全员题库答案解析 1 负载均衡加权轮询算法将请求按照顺序且根据权重分配给后端。 正确 错误 2 加权随机法是指按照权重来随机选取服务器。 正确 错误 3 负载均衡轮询算法将请求按顺序轮流分配到后台服务器上，...
操作系统精髓与设计原理答案
11-19
1.1、 列出并简要地定义计算机的四个主要组成部分。 答：主存储器，存储数据和程序；算术逻辑单元，能处理二进制数据；控制单元，解读存储器中的指令并且使他们得到执行；输入/输出设备，由控制单元管理。 1.2、 ...
编译原理龙书答案
05-13
编译原理龙书答案 完整性高 第二章 2.2 Exercises for Section 2.2 2.2.1 Consider the context-free grammar: S -> S S + | S S * | a Show how the string aa+a* can be generated by this grammar. Construct a parse tree for this string. What language does this grammar generate? Justify your answer. answer S -> S S * -> S S + S * -> a S + S * -> a a + S * -> a a + a * L = {Postfix expression consisting of digits, plus and multiple signs} 2.2.2 What language is generated by the following grammars? In each case justify your answer. S -> 0 S 1 | 0 1 S -> + S S | - S S | a S -> S ( S ) S | ε S -> a S b S | b S a S | ε ⧗ S -> a | S + S | S S | S * | ( S ) answer L = {0n1n | n>=1} L = {Prefix expression consisting of plus and minus signs} L = {Matched brackets of arbitrary arrangement and nesting, includes ε} L = {String has the same amount of a and b, includes ε} ？ 2.2.3 Which of the grammars in Exercise 2.2.2 are ambiguous answer No No Yes Yes Yes 2.2.4 Construct unambiguous context-free grammars for each of the following languages. In each case show that your grammar is correct. Arithmetic expressions in postfix notation. Left-associative lists of identifiers separated by commas. Right-associative lists of identifiers separated by commas. Arithmetic expressions of integers and identifiers with the four binary operators +, - , *, /. answer 1. E -> E E op | num 2. list -> list , id | id 3. list -> id , list | id 4. expr -> expr + term | expr - term | term term -> term * factor | term / factor | factor factor -> id | num | (expr) 5. expr -> expr + term | expr - term | term term -> term * unary | term / unary | unary unary -> + factor | - factor factor - > id | num | (expr) 2.2.5 Show that all binary strings generated by the following grammar have values divisible by 3. Hint. Use induction on the number of nodes in a parse tree. num -> 11 | 1001 | num 0 | num num Does the grammar generate all binary strings with values divisible by 3? answer prove any string derived from the grammar can be considered to be a sequence consisting of 11, 1001 and 0, and not prefixed with 0. the sum of this string is: sum = Σn (21 + 20) * 2 n + Σm (23 + 20) * 2m = Σn 3 * 2 n + Σm 9 * 2m It is obviously can divisible by 3. No. Consider string "10101", it is divisible by 3, but cannot derived from the grammar. Question: any general prove? 2.2.6 Construct a context-free grammar for roman numerals. Note: we just consider a subset of roman numerals which is less than 4k. answer wikipedia: Roman_numerals via wikipedia, we can categorize the single noman numerals into 4 groups: I, II, III | I V | V, V I, V II, V III | I X then get the production: digit -> smallDigit | I V | V smallDigit | I X smallDigit -> I | II | III | ε and we can find a simple way to map roman to arabic numerals. For example: XII => X, II => 10 + 2 => 12 CXCIX => C, XC, IX => 100 + 90 + 9 => 199 MDCCCLXXX => M, DCCC, LXXX => 1000 + 800 + 80 => 1880 via the upper two rules, we can derive the production: romanNum -> thousand hundred ten digit thousand -> M | MM | MMM | ε hundred -> smallHundred | C D | D smallHundred | C M smallHundred -> C | CC | CCC | ε ten -> smallTen | X L | L smallTen | X C smallTen -> X | XX | XXX | ε digit -> smallDigit | I V | V smallDigit | I X smallDigit -> I | II | III | ε 2.3 Exercises for Section 2.3 2.3.1 Construct a syntax-directed translation scheme that trans­ lates arithmetic expressions from infix notation into prefix notation in which an operator appears before its operands; e.g. , -xy is the prefix notation for x - y . Give annotated parse trees for the inputs 9-5+2 and 9-5*2.。 answer productions: expr -> expr + term | expr - term | term term -> term * factor | term / factor | factor factor -> digit | (expr) translation schemes: expr -> {print("+")} expr + term | {print("-")} expr - term | term term -> {print("*")} term * factor | {print("/")} term / factor | factor factor -> digit {print(digit)} | (expr) 2.3.2 Construct a syntax-directed translation scheme that trans­ lates arithmetic expressions from postfix notation into infix notation. Give annotated parse trees for the inputs 95-2* and 952*-. answer productions: expr -> expr expr + | expr expr - | expr expr * | expr expr / | digit translation schemes: expr -> expr {print("+")} expr + | expr {print("-")} expr - | {print("(")} expr {print(")*(")} expr {print(")")} * | {print("(")} expr {print(")/(")} expr {print(")")} / | digit {print(digit)} Another reference answer E -> {print("(")} E {print(op)} E {print(")"}} op | digit {print(digit)} 2.3.3 Construct a syntax-directed translation scheme that trans­ lates integers into roman numerals answer assistant function: repeat(sign, times) // repeat('a',2) = 'aa' translation schemes: num -> thousand hundred ten digit { num.roman = thousand.roman || hundred.roman || ten.roman || digit.roman; print(num.roman)} thousand -> low {thousand.roman = repeat('M', low.v)} hundred -> low {hundred.roman = repeat('C', low.v)} | 4 {hundred.roman = 'CD'} | high {hundred.roman = 'D' || repeat('X', high.v - 5)} | 9 {hundred.roman = 'CM'} ten -> low {ten.roman = repeat('X', low.v)} | 4 {ten.roman = 'XL'} | high {ten.roman = 'L' || repeat('X', high.v - 5)} | 9 {ten.roman = 'XC'} digit -> low {digit.roman = repeat('I', low.v)} | 4 {digit.roman = 'IV'} | high {digit.roman = 'V' || repeat('I', high.v - 5)} | 9 {digit.roman = 'IX'} low -> 0 {low.v = 0} | 1 {low.v = 1} | 2 {low.v = 2} | 3 {low.v = 3} high -> 5 {high.v = 5} | 6 {high.v = 6} | 7 {high.v = 7} | 8 {high.v = 8} 2.3.4 Construct a syntax-directed translation scheme that trans­ lates roman numerals into integers. answer productions: romanNum -> thousand hundred ten digit thousand -> M | MM | MMM | ε hundred -> smallHundred | C D | D smallHundred | C M smallHundred -> C | CC | CCC | ε ten -> smallTen | X L | L smallTen | X C smallTen -> X | XX | XXX | ε digit -> smallDigit | I V | V smallDigit | I X smallDigit -> I | II | III | ε translation schemes: romanNum -> thousand hundred ten digit {romanNum.v = thousand.v || hundred.v || ten.v || digit.v; print(romanNun.v)} thousand -> M {thousand.v = 1} | MM {thousand.v = 2} | MMM {thousand.v = 3} | ε {thousand.v = 0} hundred -> smallHundred {hundred.v = smallHundred.v} | C D {hundred.v = smallHundred.v} | D smallHundred {hundred.v = 5 + smallHundred.v} | C M {hundred.v = 9} smallHundred -> C {smallHundred.v = 1} | CC {smallHundred.v = 2} | CCC {smallHundred.v = 3} | ε {hundred.v = 0} ten -> smallTen {ten.v = smallTen.v} | X L {ten.v = 4} | L smallTen {ten.v = 5 + smallTen.v} | X C {ten.v = 9} smallTen -> X {smallTen.v = 1} | XX {smallTen.v = 2} | XXX {smallTen.v = 3} | ε {smallTen.v = 0} digit -> smallDigit {digit.v = smallDigit.v} | I V {digit.v = 4} | V smallDigit {digit.v = 5 + smallDigit.v} | I X {digit.v = 9} smallDigit -> I {smallDigit.v = 1} | II {smallDigit.v = 2} | III {smallDigit.v = 3} | ε {smallDigit.v = 0} 2.3.5 Construct a syntax-directed translation scheme that trans­ lates postfix arithmetic expressions into equivalent prefix arithmetic expressions. answer production: expr -> expr expr op | digit translation scheme: expr -> {print(op)} expr expr op | digit {print(digit)} Exercises for Section 2.4 2.4.1 Construct recursive-descent parsers, starting with the follow­ ing grammars: S -> + S S | - S S | a S -> S ( S ) S | ε S -> 0 S 1 | 0 1 Answer 1） S -> + S S | - S S | a void S(){ switch(lookahead){ case "+": match("+"); S(); S(); break; case "-": match("-"); S(); S(); break; case "a": match("a"); break; default: throw new SyntaxException(); } } void match(Terminal t){ if(lookahead = t){ lookahead = nextTerminal(); }else{ throw new SyntaxException() } } 2） S -> S ( S ) S | ε void S(){ if(lookahead == "("){ S(); match("("); S(); match(")"); S(); } } 3） S -> 0 S 1 | 0 1 void S(){ switch(lookahead){ case "0": match("0"); S(); match("1"); break; case "1": // match(epsilon); break; default: throw new SyntaxException(); } } Exercises for Section 2.6 2.6.1 Extend the lexical analyzer in Section 2.6.5 to remove com­ ments, defined as follows: A comment begins with // and includes all characters until the end of that line. A comment begins with /* and includes all characters through the next occurrence of the character sequence */. 2.6.2 Extend the lexical analyzer in Section 2.6.5 to recognize the relational operators <, =, >. 2.6.3 Extend the lexical analyzer in Section 2.6.5 to recognize float­ ing point numbers such as 2., 3.14, and . 5. Answer Source code: commit 8dd1a9a Code snippet(src/lexer/Lexer.java)： public Token scan() throws IOException, SyntaxException{ for(;;peek = (char)stream.read()){ if(peek == ' ' || peek == '\t'){ continue; }else if(peek == '\n'){ line = line + 1; }else{ break; } } // handle comment if(peek == '/'){ peek = (char) stream.read(); if(peek == '/'){ // single line comment for(;;peek = (char)stream.read()){ if(peek == '\n'){ break; } } }else if(peek == '*'){ // block comment char prevPeek = ' '; for(;;prevPeek = peek, peek = (char)stream.read()){ if(prevPeek == '*' && peek == '/'){ break; } } }else{ throw new SyntaxException(); } } // handle relation sign if("".indexOf(peek) > -1){ StringBuffer b = new StringBuffer(); b.append(peek); peek = (char)stream.read(); if(peek == '='){ b.append(peek); } return new Rel(b.toString()); } // handle number, no type sensitive if(Character.isDigit(peek) || peek == '.'){ Boolean isDotExist = false; StringBuffer b = new StringBuffer(); do{ if(peek == '.'){ isDotExist = true; } b.append(peek); peek = (char)stream.read(); }while(isDotExist == true ? Character.isDigit(peek) : Character.isDigit(peek) || peek == '.'); return new Num(new Float(b.toString())); } // handle word if(Character.isLetter(peek)){ StringBuffer b = new StringBuffer(); do{ b.append(peek); peek = (char)stream.read(); }while(Character.isLetterOrDigit(peek)); String s = b.toString(); Word w = words.get(s); if(w == null){ w = new Word(Tag.ID, s); words.put(s, w); } return w; } Token t = new Token(peek); peek = ' '; return t; } Exercises for Section 2.8 2.8.1 For-statements in C and Java have the form: for ( exprl ; expr2 ; expr3 ) stmt The first expression is executed before the loop; it is typically used for initializ­ ing the loop index. The second expression is a test made before each iteration of the loop; the loop is exited if the expression becomes O. The loop itself can be thought of as the statement {stmt expr3 ; }. The third expression is executed at the end of each iteration; it is typically used to increment the loop index. The meaning of the for-statement is similar to expr1 ; while ( expr2 ) {stmt expr3 ; } Define a class For for for-statements, similar to class If in Fig. 2.43. Answer class For extends Stmt{ Expr E1; Expr E2; Expr E3; Stmt S; public For(Expr expr1, Expr expr2, Expr expr3, Stmt stmt){ E1 = expr1; E2 = expr2; E3 = expr3; S = stmt; } public void gen(){ E1.gen(); Label start = new Lable(); Lalel end = new Lable(); emit("ifFalse " + E2.rvalue().toString() + " goto " + end); S.gen(); E3.gen(); emit("goto " + start); emit(end + ":") } } 2.8.2 The programming language C does not have a boolean type. Show how a C compiler might translate an if-statement into three-address code. Answer Replace emit("isFalse " + E.rvalue().toString() + " goto " + after); with emit("ifNotEqual " + E.rvalue().toString() + " 0 goto " + after); or emit("isNotEqualZero " + E.rvalue().toString() + " goto " + after);
编译原理答案 课后答案 计算机
10-08
第三章 1、 L(G[S])={ abc } 2、 L(G[N])={ n位整数或空字符串 | n>0 } 3、 G[E]：E—>E+D | E-D | D D—>0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 4、 L(G[Z])={ anbn | n>0 } 5、 (1) 考虑不包括“0”的情况 G[S]：S—>0S | ABC | 2 | 4| 6 | 8 A—>1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 B—>AB | 0B | ε C—>0 | 2 | 4 | 6 | 8 考虑包括“0”的情况： G[S]：S—>AB | C B—>AB | C A—>0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 C—>0 | 2 | 4 | 6 | 8 (2)方法1： G[S]：S—> ABC | 2 | 4 | 6 | 8 A—>1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 B—>AB | 0B | ε C—>0 | 2 | 4 | 6 | 8 方法2： G[S]：S—>AB | C B—> AB | 0B | C | 0 A—> 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 C—>2 | 4 | 6 | 8
编译原理第二版课后答案
12-12
编译原理第二版课后习题答案，张素琴主编的。PDF版本。基本答案都有
编译原理学习笔记 -- 绪论1
weixin_30553837的博客
06-16 130
1. 语言处理器语言处理系统 _________ 经过预 _______ 源程序 --> |预处理器| --> 处理的 --> |编译器| --> 目标汇编程序 -------- 源程序 ------- _______ 可重定位的 ______________ --&gt...
编译原理——编译器与解释器的区别，编译器的结构与一些常见编译器的认识
没有标题
09-09 2601
在初步学习编译原理时，遇到了一些不能很直观理解的概念，以下是我结合书本和网上学习的一些见解。 编译器：在一个程序可以运行之前，它首先需要被翻译成一种能够被计算机执行的形式，简单地说，一个编译器就是一个程序，他可以阅读以某一种语言（源语言）编写的程序，并把该程序翻译成为一个等价的、用另一种语言（目标语言）编写的程序，执行时不在需要编译器，直接在支持目标代码的平台上运行，这样执行效率比解释执行快很多...
编译原理（龙书）：第一章部分题目参考答案
乔卿的博客
01-29 3490
1.1.1 What is the difference between a compiler and an interpreter? 编译器：负责把一种编程语言编写的源码转换成另外一种计算机代码，后者往往是以二进制的形式保存。这个转换的过程通常的目的是生成可执行的程序。编译器把源代码转换成其他的更低级的代码(例如二进制码、机器码)，但是不会执行它。 解释器：直接一条一条执行由编程语言或脚本语言编写的代码，并不会把源代码预编译成机器码。解释器会读取源代码，并且直接生成指令让计算机硬件执行，不会输出另外
编译原理习题（含答案）
Alex
05-07 1万+
语法分析_11 如果文法G是无二义的，则它的任何句子α( )。A. 最左推导和最右推导对应的语法树必定相同B.  最左推导和最右推导对应的语法树可能不同C. 最左推导和最右推导必定相同D.  可能存在两个不同的最左推导，但它们对应的语法树相同 2 采用自上而下分析，不必( )。A...
编译原理题-带答案
dan_dan的博客
04-20 6868
一、判断题（） 1．一个 LL(l)文法一定是无二义的。 ( N) 2．正规文法产生的语言都可以用上下文无关文法来描述。 ( N) 3．一张转换图只包含有限个状态，其中有一个被认为是初态，最多只有一个终态。 ( Y) 4．目标代码生成时，应考虑如何充分利用计算机的寄存器的问题。 ( N) 5．逆波兰法表示的表达式亦称前缀式 。 (Y ) 6．如果一个文法存在某个句子对应两棵不同的语法树，则称这个文法是二义的。 (Y ) 7．LR 法是自顶向下语法分析方法。 ( N) 8．数组元素的地址计算与数组的存储方式有
编译原理MOOC部分习题答案+解读(逐渐更新..
syStardust的博客
02-23 3906
HIT编译原理慕课MOOC习题解读
匹配所有符合IP地址规范的字符串，例如"192.168.1.1" 答案是 ^\d{3}\.\d{3}\.\d\.\d
最新发布
05-27
您给出的答案存在一些问题，因为IP地址的第二个和第三个段落可能不是三个数字，而是一到两个数字。同时，您的正则表达式也没有考虑到IP地址的范围限制（每个段落的取值范围在0到255之间）。正确的答案应该是 `^((25...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值