[TRE-SP] Comentários Desenvolvimento

TRE-SP, provas e gabaritos no ar! Vamos aos comentários de desenvolvimento? Galerinha, fiquem à vontade para indicar outras questões e possíveis divergências ou erros (a essa altura da madruga, é bem possível que escape algo :)).

A prova de técnico caiu bastante coisa de desenvolvimento! Como tinha dito pra vocês no aulão, muita coisa de Java. Vamos às questões!

L12 Técnico Judiciário Área Apoio Especializado – Especialidade Programação de Sistemas

34. Considere a lógica do algoritmo, abaixo, expressa em pseudocódigo.

Var
tipo V = vetor [0..4] inteiro
var j, voto: inteiro
votos: V
Início
para (j <- 0 até 4 passo 1) faça
votos[j] <- 0
fim para

enquanto (verdadeiro)
imprima ("Digite o voto (1,2,3 ou 0 (branco) -1 finaliza): ")
leia (voto)
se (voto = -1)
então vá para RESULT
fim se
se (voto 3)
então votos[4] <- votos[4] + 1
senão votos[voto] <- votos[voto] + 1
fim se
fim enquanto

RESULT:
para (j <- 1 até 3 passo 1) faça
imprima ("O candidato ", j," obteve ", votos[j], " votos")
fim para

imprima ("Número de votos em branco= ", ..I..)
imprima ("..II..", votos[4])
Fim

De acordo com a lógica apresentada,
(A) logo após RESULT:, a instrução para deveria se iniciar em 0 e ir até 4.
(B) a instrução se (voto 3) deveria utilizar o operador lógico E ao invés do OU.
(C) a lacuna I deve ser preenchida com votos[1]
(D) a lacuna II deve ser preenchida com Número de votos nulos =
(E) para saber o número total de eleitores basta percorrer o vetor e somar todas as posições de 1 a 3.

A – Não, pois na verdade esse "para" é justamente para imprimir os votos várlidos, ou seja, os candidatos de 1 a 3. Item incorreto.
B – Como algo vai ser menor que zero e maior que 3 ao mesmo tempo? Viajandão! Item incorreto.
C – Votos em branco são aqueles com valor 0 e também estão sendo contabilizados na posição 0 do vetor (isso está na instrução votos[voto] <- votos[voto] + 1). Ou seja, votos[1] não contabilizam os votos em branco, mas sim os do candidato de número 1. Item incorreto
D – Boa! A 5a posição do vetos, ou seja, votos[4] está armazenando os valores inválidos de voto, ou seja, os valores nulos. Item correto.
E – Não! E os votos em branco? E os votos nulos? Deve-se somar de 0 a 4 para ter a quantidade de eleitores. Item incorreto.

GABARITO D

35. Considere as duas funções, abaixo, escritas em pseudocódigo, que implementam uma lógica.

função f1 (N: inteiro): real
Início
se (N<=1)
então retorna 1
senão retorna (N * f1 (N – 1))
fim se

Fim

função f2 (N: inteiro): real
Var i: inteiro
result: real
Início
result <- 1
para (i <- 2 até N passo 1) faça
result <- result * i
fim para
retorna result
Fim

A função
(A) iterativa e a função recursiva retornam 1 para valores de N=0 e N=1.
(B) f1 e a função f2 recebem uma variável real e retornam um valor inteiro.
(C) f1 é executada apenas uma vez, já que em seu corpo existe apenas um comando condicional.
(D) f2 é executada N-2 vezes.
(E) recursiva faz cálculos e apresenta resultados totalmente diferentes da função iterativa.

A – Certo de primeira, que sem graça. Tanto f1 quanto f2 retornam valor 1 nos casos de n = 0 ou n = 1
B – Recebem inteiro e retornam real. Item incorreto.
C – Meio tosco esse item. Tinha que dar um exemplo de chamada da função, pois dependendo do parâmetro somente chamaria f1 uma vez (n = 0, por exemplo). Mas, de qualquer forma, a quantidade de vezes em que uma função é chamada não tem nada a ver com a quantidade de estruturas de decisão (condicional). Item incorreto.
D – Mais um item tosco. Onde estão as chamadas à função f2? De qualquer forma, a função pode ser chamada quantas vezes o código principal (que não está presente na questão) quiser. Item incorreto.
E – As funções são equivalentes, sendo uma recursiva e outra iterativa. Item incorreto.

GABARITO A

36. Considere, hipoteticamente, que um Técnico do TRE-SP tem, em seu computador, a seguinte organização de um diretório:
Principal: Dados
Dentro de Dados: Técnicos Práticos
Dentro de Técnicos: Árvores Hash Recursão Filas Pilhas
Dentro de Práticos: Programas AFazer Prontos
Dentro de Prontos: Eleições Urnas
Dentro de Programas: Corretos ComErro
Dentro de ComErro: Urgentes Pendentes Antigos
A estrutura de dados
(A) hashing, ao armazenar este diretório, não terá colisões na tabela de dispersão.
(B) fila é a mais adequada para representar este diretório.
(C) pilha é a mais adequada para representar este diretório.
(D) árvore binária, ao armazenar este diretório, terá Dados na raiz e nós com grau 2, 3, 5 e folhas.
(E) árvore, que consegue armazenar este diretório, é de ordem 5.

A – Qual a função de hashing?? Só sabemos se tem ou não colisão com a função e, a partir daí, se os resultados colidem ou não. Item incorreto
B – Estrutura linear para armazenar algo hierárquico não é o mais adequado. É possível, mas não mais adequado. Item incorreto.
C – Vide B. Item incorreto.
D – Árvore binária com grau 5? Hello??? Item incorreto.
E – Massa! Vejam na árvore que montei (não ficou linda??), temos que a ordem é 5. Item correto.

GABARITO E

38. Considere o trecho de código Java, abaixo, que implementa um método de ordenação de vetores.

public class Ordena {
public static void main(String[] args) {
int[] vet = {8, 19, 31, 25, 1};
int aux = 0, i = 0;
for (i = 0; i < 5; i++) {
for (int j = 0; j vet[j + 1]) {
aux = vet[j];
vet[j] = vet[j + 1];
vet[j + 1] = aux;
}
}
}

for (i = 0; i < 5; i++) {
System.out.println(" " + vet[i]);
}
}
}

Considere que n se refere à quantidade de valores a serem ordenados. O método de ordenação implementado, com os devidos ajustes, é adequado para ser utilizado por um Técnico do TRE-SP para ordenar um conjunto formado por
(A) 1 milhão de valores numéricos em ordem aleatória, pois neste caso o método é O (n).
(B) 1 milhão de valores numéricos em ordem decrescente, por ser este o melhor caso do método.
(C) quantidades pequenas de dados, por se tratar de um método O (n2) e que realiza muitas trocas.
(D) qualquer quantidade de valores numéricos em ordem aleatória, por ser este o melhor caso do método.
(E) grandes quantidades de dados, por se tratar de um método O (log2n), portanto, muito eficiente.

A – Galera, temos um for aninhado, ou seja, vai executar na ordem de O(n * n) = O(n^2). Item incorreto.
B – Na verdade o método sempre realiza as comparações, mesmo que não haja trocas. Normalmente é o que contamos para saber a complexidade do algoritmo. Desse modo, não há melhor caso ou pior caso, pois o número de comparações é sempre o mesmo. Item incorreto.
C – Legal, item correto. Esse método é O(n^2) por ter dois for aninhados, ou seja, vai executar n * (n-1) vezes. Assintoticamente esse método é, portanto, O(n * n) = O(n^2). Item correto.
D – Qualquer quantidade num algoritmo O(n^2) vai levar um bom tempo. Existem outros algoritmos melhores para ordenação de grandes quantidades de valores. Item incorreto.
E – Como vimos, o método é O(n^2) e não O(log2n). Item incorreto

GABARITO C

39. Considere que a eleição para prefeito de um município paulista produziu o seguinte resultado:
CandidatoA-1504 votos, CandidatoB-7520 votos, CandidatoC-345551 votos, CandidatoD-517440 votos, CandidatoE-2329 votos,
CandidatoF-11731 votos e CandidatoG-152 votos.
Ao armazenar estes dados em uma árvore
(A) binária de busca, tendo como chave de inserção a quantidade de votos nesta ordem, o candidato vencedor será localizado
com 3 comparações.
(B) binária de busca, tendo como chave de inserção os nomes dos candidatos nesta ordem, resultará em uma árvore de altura
mínima.
(C) binária de busca, tendo como chave de inserção a quantidade de votos nesta ordem, o candidato vencedor ficará na raiz.
(D) binária de busca perfeitamente balanceada, tendo como chave de inserção o nome do candidato, o candidato vencedor
ficará na raiz.
(E) perfeitamente balanceada, resultará em uma árvore de altura 4.

A – Construindo a árvore de busca binária, com o número de votos como chave, e inserindo na ordem de A a G, teremos a estrutura abaixo:

Ou seja, para encontrarmos o ganhador, teríamos que realizar mais de 3 comparações. Item incorreto

B – Utilizando como chave os nomes, temos que (por ordem alfabética) CandidatoA < CandidatoB < Candidato C <…. Desse modo, teríamos uma árvore de busca binária sempre com elementos à direita (o sucessor sempre maior que o antecessor), ou seja, a árvore na verdade teria tamanho máximo! Item incorreto.
C – Como vimos, o ganhador, na verdade, será uma folha. Item incorreta.
D – Uma árvore perfeitamente balanceada tem o elemento central como raiz. No nosso caso temos 7 elementos, ou seja, nosso elemento central é o 4o, o CandidatoD, ganhador da eleição. Item correto.
E – Utilizando qualquer uma das chaves, quantidade de votos, ou nome do candidato, a árvore totalmente balanceada tem altura menor que 4. Item incorreto.

GABARITO D

40. Considere o trecho de código em Java, abaixo.

class Gerente extends Funcionario {
int senha;
public boolean autentica(int senha) {
if (this.senha == senha) {
System.out.println("Acesso Permitido!");
return true;
} else {
System.out.println("Acesso Negado!");
return false;
}
}
// setter da senha omitido
}

Observando-se os conceitos de orientação a objetos, expostos no trecho em Java,
(A) todo Funcionario é um Gerente, ou seja, Gerente é classe mãe de Funcionario e Funcionario é classe filha
de Gerente.
(B) a classe Gerente herda todos os atributos e métodos da classe Funcionario. Isso é expresso pelo uso da palavra
chave extends.
(C) sempre que um objeto do tipo Funcionario for criado, este objeto possuirá também os atributos definidos na classe
Gerente, pois um Funcionario é um Gerente.
(D) a classe Funcionario também herda os atributos e métodos privados de Gerente, porém não consegue acessá-los
diretamente.
(E) Gerente é a superclasse de Funcionario e Funcionario é a subclasse de Gerente.

A – Não é verdade. Funcionario é a superclasse e Gerente a subclasse. Dessa forma, todo Gerente é um Funcionario, mas o contrário não é verdadeiro, pois podem existir outras subclasses de Funcionario. Item incorreto
B – Gerente é subclasse de Funcionario. Em Java a palavra-chave que determina essa hierarquia é extends. Item correto.
C – Como vimos, é o oposto, ou seja, o Gerente terá todos os atributos de Funcionario, mas não o contrário. Item incorreto
D – A especificação Java é clara:

Members of a class that are declared private are not inherited by subclasses of that class. Only members of a class that are declared protected or public are inherited by subclasses declared in a package other than the one in which the class is declared.

Ou seja, a subclasse não herda os membros privados. Item incorreto. OPA, OPA, professor!! Mas o item B fala que a subclasse herda TODOS os atributos e métodos. Padawan, eu entraria com recurso, fácil fácil :)

E – É o contrário, na verdade. Item incorreto.

GABARITO B

47. Considere o programa Java, abaixo.
public class Arquivo {
public static void main(String[] args) {
int mat[][] = {{ 1, 2, -1, 2, 3}, { 1, -3, 4, 2, 0}, { -3, 5, 2, 3, 4}};
int sl[] = {0, 0, 0};
int x;
x=0;
for (int i=0;i<3;i++){
for (int j=0;j<5;j++){
sl[i]=sl[i] + mat[i][j];
}
x=x+sl[i];
}
System.out.print(x);
}
}

Ao compilar e executar o programa será exibido o valor
(A) 22.
(B) 7.
(C) 4.
(D) 11.
(E) 30.

Questãozinha chatinha, fácil, mas trabalhosa na hora da prova porque temos que seguir iteração por iteração. E ainda colocam for aninhado, mas vamos nessa!

i = 0, j = 0, sl[i] = 1
i = 0, j = 1, sl[i] = 3
i = 0, j = 2, sl[i] = 2
i = 0, j = 3, sl[i] = 4
i = 0, j = 4, sl[i] = 7

x = 0 + 7 = 7

i = 1, j = 0, sl[i] = 1
i = 1, j = 1, sl[i] = -2
i = 1, j = 2, sl[i] = 2
i = 1, j = 3, sl[i] = 4
i = 1, j = 4, sl[i] = 4

x = 7 + 4 = 11

i = 2, j = 0, sl[i] = -3
i = 2, j = 1, sl[i] = 2
i = 2, j = 2, sl[i] = 4
i = 2, j = 3, sl[i] = 7
i = 2, j = 4, sl[i] = 11

x = 11 + 11 = 22

GABARITO A

48. Considere o programa Python, abaixo.
import ..I.. as b
import matplotlib.pyplot as a
x = b.linspace(0, 3, 20)
y = b.linspace(0, 9, 20)
a.plot(x, y)
a.plot(x, y, 'o')
a.show()
A lacuna I deve ser preenchida corretamente com
(A) array.
(B) numpy.
(C) matrix.
(D) mathlab.
(E) numberplot.

Galera, questão muito específica de Python, bem chata de acertar para quem não tem experiência. A biblioteca numpy é utilizara para cálculos científicos, a galera de mineração de dados gosta muito por ela conter muitas funções úteis para estatística e matemática. A função linspace cria um conjunto de números igualmente espaçados. b.linspace(0, 3, 20) retorna 20 números entre 0 e 3, e b.linspace(0, 9, 20) retorna 20 números entre 0 e 9. Essa função é útil para criar gráficos, como é o caso da questão.

GABARITO B

49. Considere o tipo de collection Java, abaixo.

Set c = new HashSet();
c.add("TRE");
c.add("TRT");
c.add("TRF");

Para percorrer e exibir cada elemento contido em c utiliza-se
(A) for (int i=0;i<=c.size();i++) {System.out.println(c.get(i));}
(B) while(c.hasNext()) {System.out.println(c.get());}
(C) while (Iterator.hasNext()){String p = i.next(); System.out.println(p);}
(D) for (String p : c) {System.out.println(p);}
(E) Iterator i = c.iterator(); while (i.next()){String p = i.hasNext(); System.out.println(p);}

A – Set não possui método get! Item incorreto
B – Vida A :)
C – Maluquice! Chamando hasNext() como método estático de Iterator, que é uma interface, tá doidão! Item errado.
D – Ah, o nosso querido for each. Item correto, iterando sobre o Set c, onde cada elemento será atribuído a p.
E – Estava indo bem, tem como iterar sobre os valores de conjunto chamando seu método iterator(). O problema está na atribuição String p = i.hasNext(), pois esse método retorna um booleano (tem ou não tem mais elementos?), e não o valor contido no conjunto.

GABARITO D

50. Um programador criou uma aplicação Java em camadas, utilizando o NetBeans 8.1 em português. Ao concluir a aplicação, foi
solicitado a gerar a documentação a partir dos códigos-fonte, expressando o resultado em formato HTML. Para isso, ele
(A) clicou no menu Executar e na opção Gerar Javadoc.
(B) usou uma ferramenta JDocument, pois o NetBeans não possui recursos para gerar a documentação no formato solicitado.
(C) clicou no menu Ferramentas, em Opções, selecionou a guia Documentação, selecionou a opção Javadoc e clicou no
botão Gerar.
(D) compilou a aplicação através da opção Executar e Documentar do menu Executar.
(E) abriu o projeto no Eclipse e gerou a documentação pelo Javadoc, pois este recurso não vem integrado ao NetBeans.

Muito bem, FCC! Pleno 2017 e vocês cobrando decoreda de ferramenta específica. Não sabem medir conhecimento, impressionante. Decoreba, galera, não fiquem tristes de perder uma questão dessas.

GABARITO A

C03 Analista Judiciário Área Apoio Especializado – Especialidade Análise de Sistemas

50. Considere a imagem abaixo, que mostra o ciclo de vida de um objeto na JPA.

Quando se cria um objeto pela primeira vez e ele ainda não passou pela JPA, o objeto está no estado new (novo). Para que ele
se torne um objeto persistente, é necessário passá-lo para o estado managed (gerenciado) e para isso é necessário chamar o
método
(A) persist da interface EntityTransaction.
(B) persist da interface EntityManager.
(C) save da interface EntityTransaction.
(D) managed da interface EntityManager.
(E) save da interface EntityManager.

Galera, a classe EntityManager gerencia o ciclo de vida dos objetos persistentes do JPA. Para tornar um objeto como persisted, o médoto persist deve ser invocado.

GABARITO B

52. Considere que em uma servlet de uma aplicação Java EE existem as linhas abaixo:

ArrayList lista = dao.consultar(nome);
request.setAttribute("lista_req", lista);
RequestDispatcher disp = request.getRequestDispatcher("dadosTRE.jsp");
disp.forward(request, response);

Na página dadosTRE.jsp, para receber a variável de requisição definida pelo método setAttribute utiliza-se a instrução:
(A) ArrayList lis = (ArrayList) request.getAttribute("lista_req");
(B) ArrayList lista = request.getParameter("lista");
(C) ArrayList lis = request.getAttribute("lista_req");
(D) ArrayList lista = (ArrayList) request.getParameter("lista_req");
(E) ArrayList lista = (ArrayList) request.getAttribute("lista");

A – Certinho. Se a variável foi incluída como atributo, o método correto é getAttribute passando o nome lista_req como parâmetro. Como esse método retorna um Object, o cast explícito é obrigatório. Item correto.
B – O método não é o getParameter, e o nome da variável incluída no request é lista_req. Item incorreto.
C – Quaaase certo, faltou o cast. Item incorreto.
D – Vide B. Item incorreto.
E – Quaaase certo também, mas o parâmetro de getAttribute deveria ser lista_req. Item incorreto.

GABARITO A

53. Considere a classe Java, abaixo.
import java.awt.*;
import javax.swing.*;
public class Tela extends ..I..{
public Tela() {
..II.. ;
setSize(500, 300);
setLocation(300, 200);
}
public static void main(String[] args) {
Tela t = new Tela();
t.setVisible(true);
}
}
A instrução da lacuna I indica herança de componentes de uma classe que adiciona suporte à arquitetura de componentes JFC/Swing. A instrução da lacuna II define um layout com 3 linhas e duas colunas. As lacunas I e II são, correta e respectivamente, preenchidas com
(A) JPanel − setLayout(new GridBagLayout(3, 2))
(B) JPanel − setLayout(new FlowLayout(3, 2))
(C) JFrame − setLayout(new GridLayout(3, 2))
(D) JFrame − setLayout(new BorderLayout(3, 2))
(E) JFrame − setLayout(new GridBagLayout(3, 2))

Questão decoreba, infelizmente. Eu sabia de cor porque trabalhei muito com Swing, mas, honestamente, não mede conhecimento. Deu ruim, FCC.

A – JPanel tem que estar dentro de um contêiner pai, como um JFrame. Item incorreto.
B – JPanel tem que estar dentro de um contêiner pai, como um JFrame. Item incorreto.
C – Certinho! JFrame é uma janela que funciona sozinha, e o GridLayout, que funciona como uma matriz, é criado com esses parâmetros (linhas, colunas). Item correto.
D – BorderLayout possui construtor com com dois parâmetros inteiros, mas não definem número de linhas e colunas. Item incorreto.
E – GridBagLayout não possui outro construtor que não o vazio (não recebe parâmetros). Item incorreto

GABARITO C

54. Considere as linhas abaixo, presentes em um método de uma aplicação Java SE que acessa um banco de dados MySQL.

Class.forName("com.mysql.jdbc.Driver");
Connection con=DriverManager.getConnection("jdbc:mysql://localhost:3307/b","r", "p");

Ao executar estas linhas podem ocorrer, respectivamente, as seguintes exceções:
(A) DriverException e SQLException.
(B) IOException e IllegalArgumentException.
(C) ClassNotFoundException e SQLException.
(D) InterruptedException e NullPointerException.
(E) ClassNotFoundException e DataBaseException.

O método forName da classe Class pode lançar a exceção ClassNotFoundException. O método getConnection da classe java.sql.DriverManager pode lançar a exceção SQLException

55. Considere a imagem de um servidor de aplicação Java EE abaixo.
As lacunas I, II e III são, correta e respectivamente, preenchidas com
(A) servlets − páginas JSP − classes de acesso a dados.
(B) páginas JSP e HTML − classes de entidade − beans de entidade.
(C) páginas HTML − classes de acesso a dados − beans de sessão.
(D) servlets − classes de entidade − classes de acesso a dados.
(E) páginas JSP − beans de sessão − classes de entidade.

A – paginas JSP são tratadas por web container. Item incorreto.
B – classes de entidade são tratadas pelo persistence provider. Item incorreto
C – beans de sessão são tratados pelo EJB Container. Intem incorreto.
D – Vide B. Item incorreto.
E – Opa, certinho. JSP e Servlets são tratados pelo Web Container. Session Beans pelo EJB Container e entidades pelo Persistence Provider. Item correto.

Isso aí, galera! Espero que tenham ido bem. Hora de fazer os recursos! Abraços!