Turmas - 1º Semestre de 2020
Turmas
1º Semestre de 2020

Desenvolva um programa na linguagem de programação SIMPLE, que indique se o número fornecido pelo usuário é um número deficiente, perfeito ou abundante.

Um número é considerado deficiente (defectivo) se a soma de seus divisores próprios é menor que o próprio número, como por exemplo o número 15, cuja soma de seus divisores próprios (1 + 3 + 5) é menor do que 15.

Um número é considerado perfeito se a soma de seus divisores próprios é igual ao próprio número, como por exemplo o número 6, cuja soma de seus divisores próprios (1 + 2 + 3) é igual a 6.

Um número é considerado abundante se a soma de seus divisores próprios é maior que o próprio número, como por exemplo o número 12, cuja soma de seus divisores próprios (1 + 2 + 3 + 4 + 6) é maior do que 12.

Caso o número seja considerado deficiente, o programa deverá retornar -1. Caso o número seja considerado perfeito, o programa deverá retornar 0. Caso o número seja considerado abundante, o programa deverá retornar 1. Caso o número fornecido pelo usuário seja menor do que 2, o programa deverá retornar -9.

Considere que a linguagem SIMPLE possua o operador de módulo (%) implementado, que retorne o resto da divisão entre dois números (mesma sintaxe do C/C++ ou Java).

100 input n
105 if n < 2 goto 190
110 let s = 0
115 let a = 1
120 if n <= a goto 150
125 let b = n % a
130 if b != 0 goto 140
135 let s = s + a
140 let a = a + 1
145 goto 120
150 if n <= s goto 165
155 let r = -1
160 goto 195
165 if n == s goto 180
170 let r = 1
175 goto 195
180 let r = 0
185 goto 195
190 let r = -9
195 print r
200 end

Apresente a Análise Preditiva Tabular, com recuperação de erros em modo pânico, da entrada (9 v (w (7 6) y 5) z 4 sobre a gramática a seguir.

G = ({A, B, C, D, E}, {v, w, x, y, z, (, ), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, P, A)
P = {A → AvB | B
     B → BwC | BxC | C
     C → CyD | CzD | D
     D → (A) | E
     E → 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9}

Eliminação da recursividade à esquerda:

G = ({A, A1, B, B1, C, C1, D, E}, {v, w, x, y, z, (, ), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, P, A)
P = {A  → BA1
     A1 → vBA1 | ε
     B  → CB1
     B1 → wCB1 | xCB1 | ε
     C  → DC1
     C1 → yDC1 | zDC1 | ε
     D  → (A) | E
     E  → 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9}

Conjuntos FIRST(α) e FOLLOW(A):

FIRST(A)  = {(, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
FIRST(A1) = {v, ε}
FIRST(B)  = {(, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
FIRST(B1) = {w, x, ε}
FIRST(C)  = {(, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
FIRST(C1) = {y, z, ε}
FIRST(D)  = {(, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
FIRST(E)  = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

FOLLOW(A)  = {), $}
FOLLOW(A1) = {), $}
FOLLOW(B)  = {v, ), $}
FOLLOW(B1) = {v, ), $}
FOLLOW(C)  = {v, w, x, ), $}
FOLLOW(C1) = {v, w, x, ), $}
FOLLOW(D)  = {v, w, x, y, z, ), $}
FOLLOW(E)  = {v, w, x, y, z, ), $}

Tabela de Análise Preditiva:

Simplificação da gramática livre de contexto:

G = ({A, B, C, D}, {v, w, x, y, z, (, ), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, P, A)
P = {A → AvB | BwC | BxC | CyD | CzD | (A) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
     B → BwC | BxC | CyD | CzD | (A) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
     C → CyD | CzD | (A) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
     D → (A) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9}

Eliminação da recursividade à esquerda:

G = ({A, A1, B, B1, C, C1, D}, {v, w, x, y, z, (, ), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, P, A)
P = {A  → BwCA1 | BxCA1 | CyDA1 | CzDA1 | ( A )A1 | 0A1 | 1A1 | 2A1 | 3A1 | 4A1 | 5A1 | 6A1 | 7A1 | 8A1 | 9A1
     A1 → vBA1 | ε
     B  → CyDB1 | CzDB1 | (A)B1 | 0B1 | 1B1 | 2B1 | 3B1 | 4B1 | 5B1 | 6B1 | 7B1 | 8B1 | 9B1
     B1 → wCB1 | xCB1 | ε
     C  → (A)C1 | 0C1 | 1C1 | 2C1 | 3C1 | 4C1 | 5C1 | 6C1 | 7C1 | 8C1 | 9C1
     C1 → yDC1 | zDC1 | ε
     D → (A) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9}

Fatoração a esquerda da gramática livre de contexto:

G = ({A, A1, A2, A3, B, B1, B2, C, C1, D}, {v, w, x, y, z, (, ), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, P, A)
P = {A  → BA2 | CA3 | ( A )A1 | 0A1 | 1A1 | 2A1 | 3A1 | 4A1 | 5A1 | 6A1 | 7A1 | 8A1 | 9A1
     A1 → vBA1 | ε
     A2 → wCA1 | xCA1
     A3 → yDA1 | zDA1
     B  → CB2 | (A)B1 | 0B1 | 1B1 | 2B1 | 3B1 | 4B1 | 5B1 | 6B1 | 7B1 | 8B1 | 9B1
     B1 → wCB1 | xCB1 | ε
     B2 → yDB1 | zDB1
     C  → (A)C1 | 0C1 | 1C1 | 2C1 | 3C1 | 4C1 | 5C1 | 6C1 | 7C1 | 8C1 | 9C1
     C1 → yDC1 | zDC1 | ε
     D → (A) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9}

Conjuntos FIRST(α) e FOLLOW(A):

FIRST(A)  = {(, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
FIRST(A1) = {v, ε}
FIRST(A2) = {w, x}
FIRST(A3) = {y, z}
FIRST(B)  = {(, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
FIRST(B1) = {w, x, ε}
FIRST(B2) = {y, z}
FIRST(C)  = {(, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
FIRST(C1) = {y, z, ε}
FIRST(D)  = {(, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

FOLLOW(A)  = {), $}
FOLLOW(A1) = {), $}
FOLLOW(A2) = {), $}
FOLLOW(A3) = {), $}
FOLLOW(B)  = {v, w, x, ), $}
FOLLOW(B1) = {v, w, x, ), $}
FOLLOW(B2) = {v, w, x, ), $}
FOLLOW(C)  = {v, w, x, y, z, ), $}
FOLLOW(C1) = {v, w, x, y, z, ), $}
FOLLOW(D)  = {v, w, x, y, z, ), $}

Tabela de Análise Preditiva:

A gramática apresentada não é LL(1), pois várias células da Tabela de Análise Preditiva possuem mais de uma produção, de modo que não é possível empregar tal método de análise na presente gramática.

Apresente a Análise de Precedência de Operadores, da entrada 1 v (2 w (3 x 4) y 5) z 6 sobre a gramática a seguir.

G = ({A, B, C, D, E}, {v, w, x, y, z, (, ), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, P, A)
P = {A → AvB | B
     B → BwC | BxC | C
     C → CyD | CzD | D
     D → ( A ) | E
     E → 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9}

Considere o seguinte programa C esquemático:

void subA() { int a, b, c, d, e; }
void subB() { int a, b, c, y, z; }
void subC() { int b, c, k, x, y; }
void subD() { int v, w, x, d, e; }
void subE() { int v, w, x, y, z; }

Caso a sequência de chamada seja subA() chama subB(); subB() chama subC(); subC() chama subD() e subD() chama subE(), e supondo-se que seja usado o escopo dinâmico, apresente a situação de cada uma das variáveis presentes no código fonte apresentado, indicando se a mesma está visível ou oculta em cada uma das funções em que foi definida.