编程：利用选择句型输出成绩的五个等级：优秀，良好，中等，及格和不及格。 利用多分支if-elseif-else语句或者switch语句

可以使用多分支if-elseif-else语句来实现输出成绩的五个等级。例如：

if(score >= 90) {
    printf("优秀");
} else if(score >= 80) {
    printf("良好");
} else if(score >= 70) {
    printf("中等");
} else if(score >= 60) {
    printf("及格");
} else {
    printf("不及格");
}

也可以使用switch语句来实现，代码如下：

switch(score / 10) {
    case 10:
    case 9:
        printf("优秀");
        break;
    case 8:
        printf("良好");
        break;
    case 7:
        printf("中等");
        break;
    case 6:
        printf("及格");
        break;
    default:
        printf("不及格");
        break;
}

相关问题

针对文法：G[E]:E->E+T|T T->T*F|F F->(E)|i 用c++编写程序利用LR(0)分析方法对该文法进行语法分析，构建i+i*i句型分析过程中符号栈的变化过程并输出分析表

由于LR(0)分析方法需要构建分析表，因此需要先构建文法的LR(0)自动机，然后根据自动机构建分析表。以下是该文法的LR(0)自动机：


其中，数字表示状态编号，S表示起始状态，接受状态用圆点表示，转移条件用小写字母表示。

根据LR(0)自动机构建分析表，需要计算每个状态的ACTION和GOTO函数。计算ACTION函数时需要分为移进、规约和接受三种情况。计算GOTO函数时需要查看自动机中每个状态的转移条件，从而确定该状态在遇到某个终结符或非终结符时应该转移到哪个状态。

以下是该文法的LR(0)分析表：

| 状态 | + | * | i | ( | ) | $ | E | T | F |
| :--------: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: |
| 0 | S4（移进）| | S5（移进）| S6（移进）| | | 1 | 2 | 3 |
| 1 | R3（规约）| R3（规约）| R3（规约）| R3（规约）| R3（规约）| R3（规约）| | | |
| 2 | R6（规约）| S7（移进）| R6（规约）| R6（规约）| R6（规约）| R6（规约）| | | |
| 3 | R9（规约）| R9（规约）| R9（规约）| R9（规约）| R9（规约）| R9（规约）| | | |
| 4 | S4（移进）| | S5（移进）| S6（移进）| | | | 8 | 3 |
| 5 | S4（移进）| | S5（移进）| S6（移进）| | | | 9 | 3 |
| 6 | S4（移进）| | S5（移进）| S6（移进）| | | | 10 | 3 |
| 7 | S4（移进）| | S5（移进）| S6（移进）| | | | | 11 |
| 8 | R1（规约）| R1（规约）| R1（规约）| R1（规约）| R1（规约）| R1（规约）| | | |
| 9 | R2（规约）| R2（规约）| R2（规约）| R2（规约）| R2（规约）| R2（规约）| | | |
| 10 | R4（规约）| R4（规约）| R4（规约）| R4（规约）| R4（规约）| R4（规约）| | | |
| 11 | R5（规约）| R5（规约）| R5（规约）| R5（规约）| R5（规约）| R5（规约）| | | |

其中，S表示移进操作，R表示规约操作。

接下来是分析句子i+i*i的分析过程：

| 步骤 | 状态栈 | 符号栈 | 输入串 | ACTION | GOTO |
| :----------: | :------------: | :------------: | :------------: | :------------: | :----------: |
| 0 | 0 | $ | i+i*i$ | S5 | 1 |
| 1 | 0 5 | i | +i*i$ | R9 | - |
| 2 | 0 | F | +i*i$ | S7 | 2 |
| 3 | 0 7 | F+ | i*i$ | S5 | 1 |
| 4 | 0 7 5 | F+i | *i$ | R9 | - |
| 5 | 0 7 10 | T | *i$ | S9 | 3 |
| 6 | 0 7 10 9 | T* | i$ | S5 | 1 |
| 7 | 0 7 10 5 | T*i | $ | R6 | - |
| 8 | 0 7 2 | T | $ | R3 | - |
| 9 | 0 | E | $ | accept | - |

其中，状态栈表示LR(0)自动机中的状态，符号栈表示从输入串中读取的符号。根据分析表中的ACTION和GOTO函数，可以得到每一步的操作：移进、规约或接受。例如，在第1步中，由于状态栈栈顶是0，符号栈栈顶是i，输入串中的下一个符号是+，根据分析表中状态0的ACTION函数，需要移进到状态5，并将+压入符号栈中。在第2步中，状态栈栈顶是0，符号栈栈顶是F，输入串中的下一个符号是+，根据分析表中状态0的GOTO函数和状态7的ACTION函数，需要将F规约为T，然后转移到状态7，并将+压入符号栈中。在最后一步中，由于状态栈栈顶是0，符号栈栈顶是E，输入串中已经没有符号了，根据分析表中状态0的ACTION函数，需要接受该句子。

针对文法：G[E]:E->E+T|T T->TF|F F->(E)|i 用c++编写程序利用LR(0)分析方法对该文法进行语法分析，构建i+ii句型分析过程中符号栈的变化过程并输出分析表

为了方便描述，我们将文法的产生式按照顺序编号，得到如下文法：

1. E -> E + T
2. E -> T
3. T -> T F
4. T -> F
5. F -> ( E )
6. F -> i

我们首先构建该文法的 LR(0) 项集族。初始项集为 {S' -> .E}，其中 S' 是一个新的起始符号，E 是文法中的非终结符号。根据 LR(0) 项集的构造规则，我们可以得到下面的项集族：

I0:
    S' -> .E
    E -> .E + T
    E -> .T
    T -> .T F
    T -> .F
    F -> .( E )
    F -> .i

I1:
    S' -> E.
    
I2:
    E -> E .+ T
    T -> .T F
    T -> .F
    F -> .( E )
    F -> .i
    
I3:
    E -> T.
    
I4:
    T -> T .F
    F -> .( E )
    F -> .i
    
I5:
    T -> F.
    
I6:
    F -> ( .E )
    E -> .E + T
    E -> .T
    T -> .T F
    T -> .F
    F -> .( E )
    F -> .i
    
I7:
    F -> i.
    
I8:
    F -> ( E .)
    
I9:
    E -> E + .T
    T -> .T F
    T -> .F
    F -> .( E )
    F -> .i
    
I10:
    T -> T F.
    F -> .( E )
    F -> .i
    
I11:
    F -> ( E .)
    
I12:
    E -> E + T.
    
I13:
    T -> T F.
    F -> ( .E )
    E -> .E + T
    E -> .T
    T -> .T F
    T -> .F
    F -> .( E )
    F -> .i
    
I14:
    T -> F.
    F -> ( .E )
    E -> .E + T
    E -> .T
    T -> .T F
    T -> .F
    F -> .( E )
    F -> .i
    
I15:
    F -> ( E .)
    
I16:
    E -> E + T.
    T -> T .F
    F -> .( E )
    F -> .i
    
I17:
    T -> T F.
    F -> ( E .)

接下来，我们需要对 LR(0) 项集族进行分析表的构造。分析表的行由状态编号表示，列由终结符号和非终结符号表示。对于每个非规约项，我们需要在对应的单元格中填写一条移进操作；对于每个规约项，我们需要在对应的单元格中填写一条规约操作。如果分析表中存在多个操作，则需要进行冲突处理。具体的构造过程如下：

1. 对于每个项集 Ii 中的每个项 A -> α .B β，如果 B 是一个非终结符号，则将对应的单元格 M[i, B] 填写为一个移进操作，将其值设为 j，其中 j 是下一个状态编号，即 Ij 包含了项 B -> .γ，其中 γ 是一个符号串。如果 B 是一个终结符号，则将对应的单元格 M[i, B] 填写为一个移进操作，将其值设为 j，其中 j 是下一个状态编号，即 Ij 包含了项 X -> α B .β，其中 X 是一个非终结符号。

2. 对于每个项集 Ii 中的每个项 A -> α .，如果 A 是非终结符号，则将对应的单元格 M[i, a] 填写为一个规约操作，将其值设为 k，其中 k 是 A -> α 的产生式编号。如果 A 是起始符号 S'，则将对应的单元格 M[i, $] 填写为接受操作。

3. 对于每个项集 Ii 和每个终结符号 a，如果 M[i, a] 中存在多个操作，则进行如下的冲突处理：

- 如果存在一个移进操作和一个规约操作，则选择移进操作；
- 如果存在两个不同的规约操作，则选择产生式编号更小的一个；
- 如果存在两个相同的规约操作，则说明文法存在二义性，无法进行 LR(0) 分析。

根据上述的构造规则，我们可以得到下面的 LR(0) 分析表：

     +    (    )    i    $    E    T    F
0    s2        s6   s7        s1   s3   s5
1    r2   s8   r2   r2   r2            
2         s6        s7             s4      
3    r4   r4   r4   r4   r4            
4         s6        s7                  
5         r6   r6   r6   r6            
6    s2        s6   s7        s9   s3   s5
7    s2        s6   s7              s10  s5
8         s6        s7                  
9    r1   s8   r1   r1   r1            
10              r3   r3   r3            

分析表中的 s 表示移进操作，r 表示规约操作。例如，M[0, +] = s2 表示在状态 0 中读入了一个 +，应该执行移进操作，并转移到状态 2。M[1, E] = r2 表示在状态 1 中读入了一个 E，应该执行规约操作，使用产生式 E -> T，将栈顶的 T 规约为 E。

接下来，我们使用该分析表对 i+i 的句型进行语法分析。假设一开始的符号栈中只包含起始符号 S'，输入串为 i+i$。根据分析表，我们可以得到下面的分析过程：

| 符号栈 | 输入串 | 输入符号 | 分析表操作 | 操作结果 |
|:-----------:|:----------------:|:----------:|:------------:|:------------:|
| 0 | i+i$ | i | s6 | s6 |
| 0 6 | +$ | + | s2 | s2 + |
| 0 6 2 + | i | i | s6 | s6 i |
| 0 6 2 6 i | $ | $ | r6 | r6 F |
| 0 6 2 5 | | | r4 | r4 T |
| 0 6 2 E | | | r2 | r2 S |

最终的分析结果是接受状态。符号栈中只剩下起始符号 S'，说明输入串 i+i 符合文法 G[E] 的规则。