(Deitel, 2003) A linguagem de programação SIMPLE é uma linguagem simples, mas ainda poderosa e de alto nível, semelhante às versões iniciais da conhecida linguagem de programação BASIC. Cada instrução da linguagem de programação SIMPLE consiste em um número de linha e um comando da linguagem. Os números de linha devem aparecer em ordem crescente. Cada comando inicia com uma das seguintes palavras reservadas da linguagem de programação SIMPLE: rem, input, let, print, goto, if/goto ou end. Desenvolva um programa na linguagem de programação SIMPLE, que apresente os termos da série de Fibonacci. A série de Fibonacci é formada pela sequência 1, 1, 2, 3, 5, 8, 13, 21, 34, .... A série de Fibonacci é de grande importância matemática, e a lei básica é que a partir do terceiro termo, todos os termos são a soma dos dois últimos termos. O número de termos a serem impressos será fornecido pelo usuário, devendo ser um valor inteiro e positivo. Por exemplo, caso o número de termos a serem impressos fornecido pelo usuário seja 7, o programa deverá apresentar como resposta a sequência de valores 1 1 2 3 5 8 13. Caso o usuário forneça um valor inválido para o número de termos, o programa deverá apresentar como resposta o valor -1.
(Aho, 2008) Considere as assertivas a seguir sobre compiladores e interpretadores:
Quantas assertivas estão corretas:
a. 1 assertiva
b. 2 assertivas
c. 3 assertivas
d. 4 assertivas
e. 5 assertivas
(Price, 2005) A construção de analisadores descendentes é auxiliada por duas funções, denominadas FIRST e FOLLOW, associadas a uma gramática G. Durante a análise descendente, as funções FIRST e FOLLOW permitem escolher qual produção deverá ser aplicada, com base no próximo símbolo de entrada. Considerando a gramática livre de contexto G₃, analise as assertivas a seguir:
G₃ = ({S, A, B, C}, {a, b, c, d}, P₃, S)
P₃ = {S → ABC
A → aA | ε
B → bB | CdA
C → cC | ε}
Quais das assertivas apresentadas estão corretas?
a. apenas as assertivas I e II.
b. apenas as assertivas I e III.
c. apenas as assertivas II e III.
d. apenas as assertivas II e IV.
e. apenas as assertivas III e IV.
(Aho, 2008) A fatoração à esquerda é uma transformação da gramática útil na produção de gramáticas adequadas para um reconhecedor sintático preditivo, ou descendente. Quando a escolha entre duas ou mais alternativas das produções-A não é clara, ou seja, elas começam com a mesma forma sentencial, podemos reescrever essas produções para adiar a decisão até que tenhamos lido uma cadeia da entrada longa o suficiente para tomarmos a decisão correta. Analise as assertivas a seguir sobre o processo de fatoração à esquerda de gramáticas livre de contexto.
A fatoração à esquerda das produções
B → xAB | CA | xB
gera as produções
B → xB₁ | CA
B₁ → AB | B
A fatoração à esquerda das produções
D → yzA | y | yz
gera as produções
D → yD₁
D₁ → zD₂ | ε
D₂ → A
A fatoração à esquerda das produções
C → xy | xDB
gera as produções
C → xC₁
C₁ → y | DB | ε
A fatoração à esquerda das produções
A → BCy | Bz | BCD
gera as produções
A → BA₁
A₁ → CA₂ | z
A₂ → y | D
Quais das assertivas apresentadas estão corretas?
a. apenas as assertivas I e II.
b. apenas as assertivas I e III.
c. apenas as assertivas I e IV.
d. apenas as assertivas II e III.
e. apenas as assertivas II e IV.
(Aho, 2008) Uma gramática possui recursão à esquerda se ela tiver um não-terminal A tal que exista uma derivação A →+ Aα para alguma cadeia α. Os métodos de análise descendentes não podem tratar gramáticas com recursão à esquerda, de modo que uma transformação é necessária para eliminar essa recursão. Analise as assertivas a seguir sobre o processo de eliminação da recursão à esquerda de gramáticas livre de contexto.
A eliminação da recursão à esquerda das produções
D → c | DB
gera as produções
D → c | D₁ | cD₁
D₁ → B | D₁ | BD₁
A eliminação da recursão à esquerda das produções
B → a | BC | DC
gera as produções
B → a | DC | aB₁ | DCB₁
B₁ → C | CB₁
A eliminação da recursão à esquerda das produções
B → a | aA | DC | DCA
D → c | BD
gera as produções
B → a | aA | DC | DCA
D → c | aD | aAD | cD₁ | aDD₁ | aADD₁
D₁ → CD | CAD | CDD₁ | CADD₁
A eliminação da recursão à esquerda das produções
B → b | bA | CB | CBA
C → a | b | BB
gera as produções
B → b | CB | bA | CBA
C → a | b | bB | bAB | CBB | CBAB
Quais das assertivas apresentadas estão corretas?
a. apenas as assertivas I e II.
b. apenas as assertivas I e III.
c. apenas as assertivas I e IV.
d. apenas as assertivas II e III.
e. apenas as assertivas II e IV.
(Sebesta, 2000) O escopo de uma variável é a faixa de comandos em que a mesma é visível, ou seja, onde a variável pode ser referenciada por aquele comando. No escopo estático (ou léxico) o escopo de uma variável é determinado através da estrutura textual do programa, enquanto que no escopo dinâmico, o escopo de uma variável é determinado através da linha de execução do programa, sendo dependente, portanto da ordem de execução das rotinas.
public class Test {
private int x, y, z;
public void sub1() { int x, y, c; }
public void sub2() { int x, b, c; }
public void sub3() { int a, b, c; }
public static void main(String[] args) { }
}
Supondo que o pseudoprograma apresentado utilize o escopo dinâmico, considere as assertivas a seguir.
main
chama sub1
; sub1
chama sub3
e sub3
chama sub2
, as variáveis visíveis durante a execução da última função chamada são y
de sub1
, x
, b
e c
de sub2
, a
de sub3
e z
de main
.main
chama sub3
; sub3
chama sub2
e sub2
chama sub1
, as variáveis visíveis durante a execução da última função chamada são x
e y
de sub1
, b
e c
de sub2
, a
de sub3
e z
de main
.main
chama sub2
; sub2
chama sub1
e sub1
chama sub3
, as variáveis visíveis durante a execução da última função chamada são x
e y
de sub1
, a
, b
e c
de sub3
e z
de main
.main
chama sub1
; sub1
chama sub2
e sub2
chama sub3
, as variáveis visíveis durante a execução da última função chamada são x
e y
de sub1
, a
, b
e c
de sub3
e z
de main
.Quais das assertivas apresentadas estão corretas?
a. apenas as assertivas I e II.
b. apenas as assertivas I e III.
c. apenas as assertivas I e IV.
d. apenas as assertivas II e III.
e. apenas as assertivas II e IV.
(Ricarte, 2008) Um analisador sintático preditivo sem recursão pode ser construído mantendo uma pilha explicitamente, em vez de implicitamente, via chamadas recursivas. O analisador é dirigido por um programa que considera X, o símbolo no topo da pilha, e a, o símbolo corrente da entrada. Se X é um não-terminal, o analisador escolhe uma produção-X consultando a entrada M[X, a] da tabela M de análise. Por outro lado, ele tenta fazer um casamento entre o terminal X no topo da pilha e o símbolo corrente a da entrada. Apresente a sequência de movimentos, com recuperação de erros em modo pânico, da entrada x y z + x z * - y, considerando a tabela M apresentada a seguir.
+ | - | * | / | x | y | z | $ | |
---|---|---|---|---|---|---|---|---|
A | sinc | sinc | sinc | sinc | A → CD | A → CD | A → CD | sinc |
D | D → ε | D → ε | D → ε | D → ε | D → ABD | D → ABD | D → ABD | D → ε |
B | B → + | B → - | B → * | B → / | sinc | sinc | sinc | sinc |
C | sinc | sinc | sinc | sinc | C → x | C → y | C → z | sinc |
Pilha | Entrada | Derivação |
---|---|---|
$ A | x y z + x z * - y $ | A → CD |
$ D C | x y z + x z * - y $ | C → x |
$ D x | x y z + x z * - y $ | |
$ D | y z + x z * - y $ | D → ABD |
$ D B A | y z + x z * - y $ | A → CD |
$ D B D C | y z + x z * - y $ | C → y |
$ D B D y | y z + x z * - y $ | |
$ D B D | z + x z * - y $ | D → ABD |
$ D B D B A | z + x z * - y $ | A → CD |
$ D B D B D C | z + x z * - y $ | C → z |
$ D B D B D z | z + x z * - y $ | |
$ D B D B D | + x z * - y $ | D → ε |
$ D B D B | + x z * - y $ | B → + |
$ D B D + | + x z * - y $ | |
$ D B D | x z * - y $ | D → ABD |
$ D B D B A | x z * - y $ | A → CD |
$ D B D B D C | x z * - y $ | C → x |
$ D B D B D x | x z * - y $ | |
$ D B D B D | z * - y $ | D → ABD |
$ D B D B D B A | z * - y $ | A → CD |
$ D B D B D B D C | z * - y $ | C → z |
$ D B D B D B D z | z * - y $ | |
$ D B D B D B D | * - y $ | D → ε |
$ D B D B D B | * - y $ | B → * |
$ D B D B D * | * - y $ | |
$ D B D B D | - y $ | D → ε |
$ D B D B | - y $ | B → - |
$ D B D - | - y $ | |
$ D B D | y $ | D → ABD |
$ D B D B A | y $ | A → CD |
$ D B D B D C | y $ | C → y |
$ D B D B D y | y $ | |
$ D B D B D | $ | D → ε |
$ D B D B | $ | sinc |
$ D B D | $ | D → ε |
$ D B | $ | sinc |
$ D | $ | D → ε |
$ | $ | aceita |
(Price, 2005) Analisadores de precedência de operadores operam sobre a classe das gramáticas de operadores, ou seja, gramáticas que os não-terminais aparecem sempre separados por símbolos terminais e que as produções não derivam a palavra vazia. A análise de precedência de operadores é bastante eficiente e é aplicada, principalmente, no reconhecimento de expressões, como expressões aritméticas e lógicas. Apresente a sequência de movimentos, da entrada (ab(ab(aba)ba)ba), considerando a tabela de precedência e a gramática G₈ apresentados a seguir.
G₈ = ({S, L}, {a, b, (, )}, P₈, S)
P₈ = {S → (L) | a
L → LbS | S}
a | b | ( | ) | $ | |
---|---|---|---|---|---|
a | > | > | > | ||
b | < | > | < | > | > |
( | < | < | < | = | |
) | > | > | > | ||
$ | < | < | < | aceita |
Pilha | Relação | Entrada | Ação | Handle |
---|---|---|---|---|
$ | < | (ab(ab(aba)ba)ba)$ | empilha ( | |
$ ( | < | ab(ab(aba)ba)ba)$ | empilha a | |
$ ( a | > | b(ab(aba)ba)ba)$ | reduz | S → a |
$ ( S | < | b(ab(aba)ba)ba)$ | empilha b | |
$ ( S b | < | (ab(aba)ba)ba)$ | empilha ( | |
$ ( S b ( | < | ab(aba)ba)ba)$ | empilha a | |
$ ( S b ( a | > | b(aba)ba)ba)$ | reduz | S → a |
$ ( S b ( S | < | b(aba)ba)ba)$ | empilha b | |
$ ( S b ( S b | < | (aba)ba)ba)$ | empilha ( | |
$ ( S b ( S b ( | < | aba)ba)ba)$ | empilha a | |
$ ( S b ( S b ( a | > | ba)ba)ba)$ | reduz | S → a |
$ ( S b ( S b ( S | < | ba)ba)ba)$ | empilha b | |
$ ( S b ( S b ( S b | < | a)ba)ba)$ | empilha a | |
$ ( S b ( S b ( S b a | > | )ba)ba)$ | reduz | S → a |
$ ( S b ( S b ( S b S | > | )ba)ba)$ | reduz | L → LbS |
$ ( S b ( S b ( S | = | )ba)ba)$ | empilha ) | |
$ ( S b ( S b ( S ) | > | ba)ba)$ | reduz | S → (L) |
$ ( S b ( S b S | > | ba)ba)$ | reduz | L → LbS |
$ ( S b ( S | < | ba)ba)$ | empilha b | |
$ ( S b ( S b | < | a)ba)$ | empilha a | |
$ ( S b ( S b a | > | )ba)$ | reduz | S → a |
$ ( S b ( S b S | > | )ba)$ | reduz | L → LbS |
$ ( S b ( S | = | )ba)$ | empilha ) | |
$ ( S b ( S ) | > | ba)$ | reduz | S → (L) |
$ ( S b S | > | ba)$ | reduz | L → LbS |
$ ( S | < | ba)$ | empilha b | |
$ ( S b | < | a)$ | empilha a | |
$ ( S b a | > | )$ | reduz | S → a |
$ ( S b S | > | )$ | reduz | L → LbS |
$ ( S | = | )$ | empilha ) | |
$ ( S ) | > | $ | reduz | S → (L) |
$ S | > | $ | aceita |