Desenvolvimento (Code + Calc)

Question 1

5. (FGV – 2021 – IMBEL) Considere um conjunto de 65.536 chaves ordenadas, distintas entre si,
   armazenadas num array.

Com relação ao processo de busca binária, assinale a opção que indica o número máximo de acessos ao array necessários para localizar uma determinada chave qualquer.

a) 10
b) 16
c) 64
d) 256
e) 32.768

Answer 1

Para isso, devemos usar a fórmula log2n = 65.536.

Na busca binária, o vetor é dividido ao meio sucessivamente, até achar o valor desejado.

Vamos ver quantas vezes conseguimos dividir por 2 o valor:

65.536/2 = 32768 (1x)
32768/2 = 16384 (2x)
16384/2 = 8192 (3x)
8192/2 = 4096 (4x)
4096/2 = 2048 (5x)
2048/2 = 1024 (6x)
1024/2 = 512 (7x)
512/2 = 256 (8x)
256/2 = 128 (9x)
128/2 = 64 (10x)
64/2 = 32 (11x)
32/2 = 16 (12x)
16/2 = 8 (13x)
8/2 = 4 (14x)
4/2 = 2 (15x)
2/2 = 1 (16x)

Portanto, são, no máximo, 16 vezes.

Gabarito: Letra B

Question 2

7. (FCC – 2013 – MPE-AM) Considere o vetor vet a seguir:

Após a execução dos seguintes comandos de atribuição:

aux ← vet[8]
vet[8] ←vet [1]
vet[4] ← vet[6]
vet[6] ← vet[3]
vet[3] ← vet[1] ← aux

A configuração do vetor (do índice 1 ao 8) será
a) ZONAAMAS
b) AMASZONA
c) SMAZONAS
d) AMASSONA
e) AMAZONAS

Answer 2

Vamos passo a passo:

aux ← vet[8]
É definido o valor de vet[8] para a variável aux. É a oitava posição do vetor, ou seja, A.
Assim, aux = A.

vet[8] ←vet [1]
À posição 8, é atribuído o valor da posição 1. Assim:
SMNAOZAS
vet[4] ← vet[6]

À posição 4, é atribuído o valor da posição 6. Assim:
SMNZOZAS
vet[6] ← vet[3]

À posição 6, é atribuído o valor da posição 3. Assim:
SMNZONAS
vet[3] ← vet[1] ← aux

Às posições 1 e 3, são atribuídos os valores de aux, que é A. Assim:
AMAZONAS

Gabarito: Letra E

Question 3

8. (FCC - 2016 - Copergás - PE - Analista Tecnologia da Informação) Considere o algoritmo a seguir, na forma de pseudocódigo:

Var n, i, j, k, x: inteiro
Var v: vetor[0..7] inteiro
Início
v[0] ← 12
v[1] ← 145
v[2] ← 1
v[3] ← 3
v[4] ← 67
v[5] ← 9
v[6] ← 45
n ← 8
k ← 3
x ← 0

Para j ← n-1 até k passo -1 faça
v[j] ← v[j - 1];
Fim_para

v[k] ← x;
Fim

Este pseudocódigo
a) exclui o valor contido na posição x do vetor v.

b) insere o valor de x entre v[k-1] e v[k] no vetor v.

c) exclui o valor contido na posição k do vetor v.

d) tentará, em algum momento, acessar uma posição que não existe no vetor.

e) insere o valor de k entre v[x] e v[x+1] no vetor v.

Answer 3

O algoritmo, na estrutra de repetição “Para j ← n-1 até k passo -1 faça” percorre o vetor de trás para frente, “empurrando” os valores para o final do vetor.

De fato, a estrutura vai da posição 7 até a 3 no vetor passando os valores da posição anterior para a posterior.

Desse modo v[6] vai para v[7], v[5] para v[6], até que o valor de v[3] fica igual ao valor de v[4].

Na última instrução v[3] recebe outro valor. Ou seja, o algoritmo “afasta” os valores, a partir da posição três, para incluir um novo valor, entre v[2] e v[3] (v[k-1] e v[k]).

Gabarito: Letra B

Question 4

8. (FGV – 2021 – IMBEL) No contexto das estruturas de dados, considere uma pilha (stack) onde as seguintes operações foram executadas.

CLEAR
PUSH (12)
PUSH (14)
POP
PUSH (20)
PUSH (15)
POP
PUSH (19)

Assinale a opção que indica o número de elementos e o valor do elemento localizado no topo da pilha, ao final das operações.

a) 3 / 12
b) 3 / 15
c) 3 / 19
d) 5 / 12
e) 5 / 19

Answer 4

Precisamos definir os comandos.

● CLEAR: limpa a pilha.
● PUSH: inclui um elemento na pilha.
●POP: retira o último elemento incluído da pilha.

Então, vamos seguir linha a linha:

CLEAR
Limpa a pilha.

PUSH (12)
Inclui o número 12 na pilha.
Pilha: (base) [12] (topo)

PUSH (14)
Inclui o número 14 na pilha.
Pilha: (base) [12, 14] (topo)

POP
Remove o número 14 da pilha.
Pilha: (base) [12] (topo)

PUSH (20)
Inclui o número 20 na pilha.
Pilha: (base) [12, 20] (topo)

PUSH (15)
Inclui o número 15 na pilha.
Pilha: (base) [12, 20, 15] (topo)

POP
Remove o número 15 na pilha.
Pilha: (base) [12, 20] (topo)

PUSH (19)
Inclui o número 19 na pilha.
Pilha: (base) [12, 20, 19] (topo)

Portanto, a pilha ficou com 3 elementos, sendo que, em seu topo, está o número 19.

Portanto, 3 / 19.

Gabarito: Letra C

Question 5

11. (FGV – 2018 – MPE-AL) Considere as seguintes operações sobre uma estrutura de dados, inicialmente vazia, organizada na forma de pilhas (ou stack),

PUSH (10)
PUSH (2)
POP ()
POP ()
PUSH (6)

Assinale a opção que apresenta a lista de elementos armazenados na estrutura, após a execução das operações acima.
a) 10, 2, 6
b) 10, 2
c) 2, 6
d) 6
e) 2

Answer 5

Precisamos definir os comandos.

● PUSH: inclui um elemento na pilha.
●POP: retira o último elemento incluído da pilha.

Então, vamos seguir linha a linha:

PUSH (10)
Inclui o número 10 na pilha.
Pilha: (base) [10] (topo)

PUSH (2)
Inclui o número 2 na pilha.
Pilha: (base) [10, 2] (topo)

POP ()
Remove o número 2 na pilha.
Pilha: (base) [10] (topo)

POP ()
Remove o número 10 na pilha.
Pilha: (base) [] (topo)

PUSH (6)
Insere o número 6 na pilha.
Pilha: (base) [6] (topo)

Ao fim, temos apenas o elemento 6.

Gabarito: Letra D

Question 6

25. (CESPE - 2004 – STJ – Analista de Sistemas)

A seguir, está representada corretamente uma operaçãode desempilhamento em uma pilha de nome p.

se p.topo = 0 então
nada {pilha vazia}
senão p.topo 🡨 p.topo-1

Answer 6

Galera, a questão deu uma vaciladinha! O ideal seria dizer p.topo = null, mas vamos subentender que foi isso mesmo que ele quis dizer.

Desse modo, se não tem topo, é porque a pilha está vazia. Se tiver topo, então o topo será o elemento anterior ao topo. O que ocorreu? Eu desempilhei a pilha!

Gabarito: Correto

Question 7

26. (CESPE - 2004 – STJ – Analista de Sistemas) A seguir, está representada corretamente uma operação de retirada em uma fila de nome f.

se f.começo = nil então
erro {fila vazia}
senão j <- f.começo.info

Answer 7

Não, o correto seria:

se f.começo = nil então
erro {fila vazia}
senão f.começo <- f.começo.anterior

Por que, professor? As duas primeiras linhas estão apenas dizendo que se o primeiro elemento da fila for Null (ou Nil), vai dar erro porque a fila está vazia, logo não há como retirar elementos de uma fila vazia.

Agora vejam a última linha: ele atribui a uma variável j o valor f.começo.info. Na verdade, ele simplesmente está colocando em j os dados do primeiro elemento da fila, mas a questão pede o código para retirar um elemento da lista e não para capturar os dados do primeiro elemento.

Na resposta, eu coloco que f.começo, i.e., o primeiro elemento da lista vai ser f.começo.anterior, ou seja, temos um novo primeiro elemento e eu retirei aquele elemento anterior.

Gabarito: Errado

Question 8

27. (FCC - 2016 - Prefeitura de Teresina - PI - Analista Tecnológico - Analista de Suporte Técnico)

Considerando uma estrutura de dados do tipo fila, e a seguinte sequência de comandos sobre essa fila (sendo que o comando Push representa uma inserção de elemento e o comando Pop representa uma exclusão de elemento) e considerando também que a fila estava inicialmente vazia:

Push 3, Push 5, Pop 3, Push 7, Pop 5, Push 9, Push 8

Após a execução dessa sequência de comandos, o conjunto de elementos que resulta na fila é:

a) 3 − 5 − 7 − 9 − 8.
b) 7 − 9 − 8 − 3 − 5.
c) 3 − 3 − 5 − 5 − 7 − 9 − 8.
d) 7 − 9 − 8.
e) 3 − 5 − 3 − 7 − 5 − 9 − 8.

Answer 8

Como a questão nem pediu a ordem, ficou bem fácil. Push inclui e pop retira. Se há dois pop’s, os elementos 3 e 5 são removidos da fila, sobrando 7, 9 e 8.

Gabarito: Letra D

Question 9

1. (IFTM – IFTM– 2023) Dada a árvore de busca binária da imagem a seguir, insira os elementos 23, 12, 64, 93, 71 e 86 (nessa ordem).

Após a inserção, qual é a saída do percurso pós-ordem?

a) 8, 12, 23, 35, 42, 56, 64, 71, 74, 77, 85, 86, 89, 91, 93, 96.

b) 74, 56, 35, 8, 23, 12, 42, 64, 71, 85, 77, 89, 86, 96, 91, 93.

c) 12, 23, 8, 42, 35, 71, 64, 56, 77, 86, 93, 91, 96, 89, 85, 74.

d) 12, 23, 8, 42, 35, 64, 56, 71, 77, 86, 93, 91, 96, 89, 85, 74.

e) Nenhuma das alternativas.

Answer 9

Pré-ordem: Raiz -> Esquerda -> Direita
Em Ordem (Simétrico): Esquerda -> Raiz -> Direita
Pós-ordem: Esquerda -> Direita -> Raiz

Vamos relembrar o conceito de árvore binária? Uma árvore binária é uma estrutura de dados
hierárquica que consiste em nós e arestas. Cada nó possui no máximo dois filhos, chamados de filho esquerdo e filho direito. A raiz da árvore é o nó superior, que não possui pais. As árvores binárias podem ser usadas para representar diversos tipos de dados, como números, strings, objetos, etc. Elas são frequentemente usadas em algoritmos de busca, ordenação e processamento de dados. Em uma árvore binária balanceada, cada nó da árvore tem a mesma altura ou a altura do nó esquerdo é um a menos que a altura do nó direito. Isso garante que a árvore possa ser percorrida de forma eficiente, usando algoritmos como a busca binária. Existem diversos algoritmos de balanceamento para árvores binárias. Um dos algoritmos mais conhecidos é o algoritmo AVL, que usa uma propriedade chamada fator de balanceamento para determinar se um nó está desbalanceado. A inserção pós-ordem é um
tipo de inserção de elementos numa árvore binária. Nessa inserção, os elementos são inseridos na árvore na seguinte ordem:

1. Inserir todos os elementos filhos do nó atual. 2. Inserir o próprio nó.

A inserção pós-ordem é frequentemente usada em algoritmos de processamento de dados que precisam visitar todos os elementos da árvore uma única vez.

Vamos juntos, passo a passo para entender como é feita a inserção nesse caso.

Inserção do elemento 23:
1. Comparamos 23 com a raiz, que é 74. Como 23 é menor que 74, seguimos para o lado esquerdo da árvore.

2. Comparamos 23 com a raiz do lado esquerdo, que é 56. Como 23 é menor que 56, seguimos para o lado esquerdo da árvore.
3. Comparamos 23 com a raiz do lado esquerdo, que é 35. Como 23 é menor que 35, seguimos para o lado esquerdo da árvore.
4. Comparamos 23 com a raiz do lado esquerdo, que é 8. Como 23 é maior que 8, inserimos 23 como o novo filho direito de 8.

Inserção do elemento 12:
1. Comparamos 12 com a raiz, que é 74. Como 12 é menor que 74, seguimos para o lado esquerdo da árvore.

2. Comparamos 12 com a raiz do lado esquerdo, que é 56. Como 12 é menor que 56, seguimos para o lado esquerdo da árvore.
3. Comparamos 12 com a raiz do lado esquerdo, que é 35. Como 12 é menor que 35, inserimos 12 como o novo filho esquerdo de 35.

Inserção do elemento 64:
1. Comparamos 64 com a raiz, que é 74. Como 64 é maior que 74, seguimos para o lado direito da árvore.

2. A raiz do lado direito é vazia, então inserimos 64 como a nova raiz do lado direito.

Inserção do elemento 93:
1. Comparamos 93 com a raiz, que é 74. Como 93 é maior que 74, seguimos para o lado direito da árvore.

2. Comparamos 93 com a raiz do lado direito, que é 64. Como 93 é maior que 64, inserimos 93
   como o novo filho direito de 64.

Inserção do elemento 71:

1. Comparamos 71 com a raiz, que é 74. Como 71 é menor que 74, seguimos para o lado esquerdo da árvore.
2. A raiz do lado esquerdo é 56. Comparamos 71 com 56. Como 71 é maior que 56, inserimos 71 como o novo filho direito de 56.

Inserção do elemento 86:
1. Comparamos 86 com a raiz, que é 74. Como 86 é menor que 74, seguimos para o lado esquerdo da árvore.

2. Comparamos 86 com a raiz do lado esquerdo, que é 56. Como 86 é maior que 56, seguimos para o lado esquerdo da árvore.
3. Comparamos 86 com a raiz do lado esquerdo, que é 35. Como 86 é maior que 35, seguimos para o lado esquerdo da árvore.
4. Comparamos 86 com a raiz do lado esquerdo, que é 23. Como 86 é maior que 23, inserimos 86 como o novo filho direito de 23

Gabarito: Letra C

Question 10

A Figura a seguir exibe uma árvore binária.

Suponha que uma função percorra essa árvore em ordem simétrica e exiba os valores de seus nós no console.

Um dos possíveis somatórios do 2º , do 3º e do 4º valores exibidos por essa função é

A 90
B 120
C 130
D 150
E 200

Answer 10

Ordem Simétrica pode ser tanto Esquerda - Raiz - Direita quanto o contrário (Direita - Raiz - Esquerda)

A banca pediu para percorrer a árvore de forma assimétrica, ou seja, em Ordem, que é ERD (Esquerda, Raiz, Direita). No entanto, não é apenas essa forma que pode ser usada, podendo também ser DRE (Direita, Raiz, Esquerda). Essa foi a pegadinha da questão, pois estamos sempre acostumados a percorrer de forma ERD.

Neste sentido, você deve percorrer a árvore pelo lado direito e exibir todos os valores dessa árvore. A sequência seria (40, 30, 20, 70, 100, 60, 10, 80, 50, 90), em que os 2º, 3º e 4º valores, destacados em negrito, somam 120. Portanto, a resposta correta é a letra B.

Fique atento, pois a banca pode fazer a brincadeira de trocar a esquerda e a direita nas ordens de pré-ordem, em ordem e pós-ordem e como não existia nenhuma alternativa que desse a resposta correta se você começasse pela esquerda ERD que daria 140, então era testar pelo lado direito.

Gabarito: B

Question 11

Os seguintes números serão inseridos, nessa ordem, em uma árvore AVL: 3, 13, 17, 23, 7, 9, 21, 25, 2.

O quinto elemento da árvore a ser visitado, quando é realizada uma busca em pré-ordem, é o número:

A 2;
B 9;
C 13;
D 17;
E 25.

Answer 11

Para resolver a questão e encontrar o quinto elemento a ser visitado em uma busca em pré-ordem (também conhecida como “preorder traversal”) em uma árvore AVL, primeiro precisamos construir a árvore AVL com os números fornecidos, seguindo as regras de balanceamento da árvore AVL.

Os números fornecidos são: 3, 13, 17, 23, 7, 9, 21, 25, 2.

Vamos inserir os números um por um, ajustando a árvore para manter a propriedade AVL (balanceamento de alturas) após cada inserção.

A arvore vai ficar:

   3
/     \   2     13
      / \
    7   17
       \   \
       9  23
            / \
         21 25

Busca em pré-ordem ponto À esquerda de cada nó.

Gabarito: B

Question 12

10. (FGV – 2018 – Câmara de Salvador - BA) Gerenciadores de bancos de dados frequentemente empregam índices implementados na forma de árvores B. Nesse tipo de organização, considerando-se uma árvore na qual o número máximo de chaves numa página não folha é 19 (ou seja, d=20), o número máximo de acessos necessários para localizar uma chave, num universo de 10 milhões de chaves distintas, é:

a) 4;
b) 7;
c) 19;
d) 100;
e) 316.

Answer 12

O limite superior da profundidade da árvore é d ≤ 1 + logd/2, sendo que:

● d = a ordem da árvore, ou seja, o número máximo de chaves numa página não folha. Neste caso, d = 20.

● N = a quantidade de registros. Neste caso, N =
10.000.000

Portanto, calculemos:
d ≤ 1 + logd/2
d ≤ 1 + log20/2
d ≤ 1 + log[10]((10.000.001/2)
d ≤ 1 + log10

Para calcularmos na mão este logaritmo, vamos fazer multiplicando 10 por 10 até chegarmos no valor, para termos alguma ideia.

Portanto:
1010 = 100 (2x)
10010 = 1.000 (3x)
1.00010 = 10.000 (4x)
10.00010 = 100.000 (5x)
100.00010 = 1.000.000 (6x)
1.000.00010 = 10.000.000 (7x)

Note do 6 para o 7, o valor ultrapassou 5.000.000,5. Portanto log10 é mais ou menos 6,5, com um arredondamento bem estimado.

Então:
d ≤ 1 + log10
d ≤ 1 + 6,5
d ≤ 7,5

Portanto, a quantidade máxima de acessos é d ≤ 7,5. Como a quantidade máxima de acessos é um número inteiro, então é 7.

Gabarito: Letra B

Question 13

11. (FGV – 2018 – MPE-AL) Em uma árvore B de ordem d, onde cada nó que não o raiz possui entre d e 2d chaves, estão armazenadas 30.000 chaves.

Sabendo-se que d=8, assinale a opção que indica o número máximo de nós visitados para a localização de uma chave.
a) 3
b) 5
c) 7
d) 15
e) 15.000

Answer 13

O limite superior da profundidade da árvore é d ≤ 1 + logm/2, sendo que:

● m = a ordem da árvore, ou seja, o número máximo de chaves numa página não folha. Neste caso, m = 16, porque a quantidade máxima de chaves numa página é 2d = 2*8 = 16.

● N = a quantidade de registros. Neste caso, N =
30.000 Assim:

d ≤ 1 + logm/2
d ≤ 1 + log16/2
d ≤ 1 + log8
d ≤ 1 + log8

Vamos calcular log8 multiplicando 8 por 8 até o valor ultrapassar 15.000,5: 8*8 = 64 (2x)

648 = 512 (3x)
5128 = 4.096 (4x)
4.096*8 = 32.768 (5x)

Note que o valor ultrapassa 15.000 do 4 para o 5. Portanto, log8 está entre 4 e 5. Vamos arredondar e dizer que é 4,5.

d ≤ 1 + 4,5
d ≤ 5,5

Como a quantidade máxima de tentativas é um inteiro, então é 5.

Question 14

17. (FGV – 2021 – IMBEL) Considere uma árvore B+ com as seguintes características.

I. A raiz é uma folha ou um nó que contém, no mínimo, dois filhos.

II. Cada nó diferente do nó raiz e das folhas possui no mínimo d filhos.

III. Cada nó tem no máximo 2d filhos. Cada nó possui entre d-1 e 2d-1 chaves, exceto o raiz que possui entre 1 e 2d-1 chaves.

IV. Somente os nós folhas contêm dados associados às chaves.

Assinale o número máximo de acessos necessários para localizar uma chave, com d=10, num universo de 10 milhões de chaves.

a) 5
b) 7
c) 10
d) 100
e) 1.000

Answer 14

O número máximo de acessos é calculado pela fórmula log d n. Para d = 10 e n = 10.000.000, temos log 10 10000000 = 7.

Gabarito: Letra B

Question 15

5. (FGV – 2021 – TJ-RO) Considere a lista duplamente encadeada exibida a seguir.

(1, 3, 0, “Verde”)
(2, 4, 3, “Azul”)
(3, 2, 1, “Amarelo”)
(4, 0, 2, “Vermelho”)

Cada elemento pertencente à lista é representado por uma quádrupla, com o seguinte formato:

(<id>, <id>, <id>, <conteúdo>).</conteúdo></id></id></id>

A ordem do conteúdo dos componentes, segundo a instância da lista apresentada, é:

a) Amarelo, Verde, Azul, Vermelho;
b) Azul, Verde, Vermelho, Amarelo;
c) Verde, Vermelho, Amarelo, Azul;
d) Vermelho, Amarelo, Azul, Verde;
e) Vermelho, Azul, Amarelo, Verde.

Answer 15

Considerando que o primeiro número é o ID, temos os seguintes IDs:

ID Cor
1 Verde
2 Azul
3 Amarelo
4 Vermelho

De linha a linha, vamos analisando:

(1, 3, 0, “Verde”)
O verde vem depois do 3 (Amarelo), e antes do 0. Como não existe 0, então sabemos que:
Lista: Amarelo - Verde

(2, 4, 3, “Azul”)
O azul vem depois do 4 (Vermelho), e antes do 3 (Amarelo), então sabemos que:
Lista: Vermelho - Azul – Amarelo – Verde

Apenas com essas duas linhas, já sabemos a ordem que é a letra D, certo? Mas… vamos conferir as demais.

(3, 2, 1, “Amarelo”)
Diz que o Amarelo vem depois do 2 (Azul) e antes do 1 (Verde). Está certo.

(4, 0, 2, “Vermelho”)
Diz que o Vermelho vem depois do 0 (não existe, portanto, é o primeiro), e depois do 2 (Azul). Certo também.

A lista é Vermelho - Azul – Amarelo – Verde.

Gabarito: Letra E

Question 16

24. (CESPE - 2009 - ANAC - Especialista em Regulação - Economia)

Considerando-se uma árvore binária completa até o nível 5, então a quantidade de folhas nesse nível será 24.

Answer 16

Não! A quantidade de folhas em um determinado nível – considerando a raiz como nível 0 –, é dada pela fórmula 2^d, portanto 32.

Gabarito: Errado

Question 17

25. (CESPE - 2009 – ANAC - Analista de Sistemas)

Uma árvore binária completa até o nível 10 tem 2.047 nós.

Answer 17

Se possui 10 níveis, possui [2^(d+1)] -1 : 2047 nós!!

Gabarito: Correto

Question 18

44. (CESGRANRIO – 2010 – PETROBRÁS - Analista de Sistemas) Uma sequência desordenada de números armazenada em um vetor é inserida em uma árvore AVL. Após a inserção nesta árvore, é feito um percurso em ordem simétrica (em ordem) e o valor de cada nó visitado é inserido em uma pilha.

Depois de todos os nós serem visitados, todos os números são retirados da pilha e apresentados na tela. A lista de números apresentada na tela está:

a) ordenada ascendentemente de acordo com os números.

b) ordenada descendentemente de acordo com os números.

c) na mesma ordem do vetor original.

d) na ordem inversa do vetor original.

e) ordenada ascendentemente de acordo com sua altura na árvore.

Answer 18

Essa questão é legal! Olha só…

Eu tenho um vetor com um bocado de valor desordenado. Esses valores são colocados em uma Árvore AVL.

Ora, uma árvore AVL é uma árvore binária de busca, portanto segue suas propriedades. Logo, não importa se estava desordenado. À medida que são inseridos os valores desordenados na árvore, ela vai se balanceando e ordenando os dados.

Após isso, vamos retirar os dados da Árvore AVL. Como? Da esquerda para a direita! E vamos colocá-los em uma pilha.

Se estamos lendo da esquerda para a direita, estamos retirando do menor valor para o maior
valor, logo o maior valor da pilha será o maior valor da Árvore AVL.

Por fim, ao retirar os elementos da pilha,
retiramos do topo (maior) para a base (menor), logo em ordem descendente.

Gabarito: Letra B

Question 19

48. (CESPE – 2010 – PETROBRÁS - Analista de Sistemas) No sistema de dados do Departamento de Recursos Humanos de uma grande empresa multinacional, os registros de funcionários são armazenados em uma estrutura de dados do tipo árvore binária AVL, onde cada registro é identificado por uma chave numérica inteira.

Partindo de uma árvore vazia, os registros cujas chaves são 23, 14, 27, 8, 18, 15, 30, 25 e 32 serão, nessa ordem, adicionados à árvore. Dessa forma, o algoritmo de inserção na árvore AVL deverá realizar a primeira operação de rotação na árvore na ocasião da inserção do elemento:

a) 30
b) 25
c) 18
d) 15
e) 8

Answer 19

Vamos simular! Vamos inserir logo os três primeiros: 23, 14 e 27 (primeira imagem); depois inserimos o número 8 (segunda imagem); e inserimos o número 18 (terceira imagem).

Agora vamos inserir o 15! Esse nó iria para a esquerda de 18 como mostra a primeira imagem abaixo. Nesse caso, o nó 23 ficaria desbalanceado.

O que fazer?

Temos um Caso Esquerda-Direita, portanto temos que fazer uma rotação dupla: primeiro à esquerda no Ramo 14-18 e depois à direita no Ramo 18-23. O resultado é mostrado a imagem abaixo e é na inserção do nó 15 que devemos fazer a primeira rotação.

Gabarito: Letra D

Question 20

49. (CESPE – 2014 – TJ/SE - Analista de Sistemas) Existem dois vetores, chamados A e B, que estão ordenados e contêm N elementos cada, respeitando a propriedade A[N-1]<B[0], onde os índices de ambos os vetores vão de 0 a N-1.

Retiram-se primeiro todos os elementos de A na ordem em que se apresentam e inserem-se esses elementos em uma árvore binária de busca, fazendo o mesmo depois com os elementos de B, que são inseridos na mesma árvore de busca que os de A.

Depois, retiram-se os elementos da árvore em um percurso pós ordem, inserindo-os em uma pilha. Em seguida retiram-se os elementos da pilha, que são inseridos de volta nos vetores, começando pelo elemento 0 do vetor A e aumentando o índice em 1 a cada inserção, até preencher todas as N posições, inserindo, então, os N elementos restantes no vetor B da mesma maneira.

Ao final do processo, tem-se que os vetores:

a) estão ordenados e A[i] < B[i], para todo i=0,. , N-1.

b) estão ordenados e A[i] > B[i], para todo i=0,…., N-1.

c) estão ordenados e não existe mais uma propriedade que relacione A[i] e B[i].

d) não estão ordenados e A[i] < B[i], para todo i=0,…., N-1.

e) não estão ordenados e A[i] > B[i], para todo i=0,…., N-1.

Answer 20

Ele diz que nós temos dois vetores em que A[N-1] < B[0]. Então, vamos imaginá-los aqui:

• Vetor A = [1, 3, 5]
• Vetor B = [7, 9, 11]

Depois ele diz que são retirados todos os elementos de A na ordem que se apresentam e são inseridos em uma árvore binária de busca (lembre-se que uma árvore binária de busca é aquela em que todos os nós da subárvore esquerda possuem um valor numérico menor que o da raiz e os nós da subárvore direita
possuem um valor numérico maior que o da raiz).

Se você desenhar essa árvore, vai perceber que ela vai ficar em ordem toda para a direita - sem nenhum elemento para esquerda. Dito isso, ficou:

• 1, 3, 5, 7, 9, 11.

Depois ele disse que os elementos foram retirados da árvore em pós-ordem, ou seja, subárvore à esquerda, depois subárvore à direita e só depois raiz. Portanto, não tem elemento na esquerda, você retira o
elemento da direita e depois a raiz. E são colocados em uma pilha, logo ficaria:

• 11, 9, 7, 5, 3, 1

Lembrando que numa pilha você insere sempre elementos no topo, logo 1 seria o topo da pilha.

Depois ele diz que você retira os elementos da pilha (também sempre pelo topo) e coloca de volta nos vetores. Logo, ficaria:

• Vetor A = [1, 3, 5]
• Vetor B = [7, 9, 11]

Pronto! Note que fica exatamente a mesma coisa e os vetores ficariam ordenados e A[i] < B[i], para todo i=0,. , N-1. Bacana?

Gabarito: Letra A

Question 21

8. (FCC – 2017 – ARTESP) Considere a estrutura de dados abaixo.

Esta estrutura representa cinco localidades indicadas por 0, 1, 2, 3, 4 com as rotas e as respectivas distâncias entre
elas.

Por exemplo, da localidade 0 há rota para a localidade 1 (distância 10) e para a localidade 2 (distância 5). Um Especialista em Tecnologia da Informação da ARTESP afirma, corretamente, que

a) partindo de qualquer uma das localidades é possível ir para todas as outras e voltar para a localidade de
origem.

b) a distância da rota direta partindo de uma localidade x para uma localidade y não é a mesma da rota de retorno
de y para x.

c) a rota direta mais longa entre duas localidades é 9.

d) a rota mais curta partindo da localidade 3 e chegando na localidade 2 é 9.

e) é possível ir e voltar de todas as localidades adjacentes.

Answer 21

É possível desenhar as rotas da seguinte maneira:

Vamos analisar item a item:
a) partindo de qualquer uma das localidades é possível ir para todas as outras e voltar para a localidade de origem.

É possível ir a qualquer uma das localidades para todas as outras, e voltar para a localidade de origem. A banca definiu este item como errado. Acredito que tenha considerado que é possível, mas não diretamente, e, também, não pelo mesmo caminho. Falso.

b) a distância da rota direta partindo de uma localidade x para uma localidade y não é a mesma da rota de retorno de y para x.
As distâncias são diferentes, de fato.

Por exemplo, de 0 para 1, a distância é 10. Mas, de 1 para 0, é possível fazer o caminho 1-3-4-0, cuja distância é 1+4+7 = 12, ou o caminho 1-2-4-0, cuja distância é 2+2+7 = 11. Verdadeiro.

c) a rota direta mais longa entre duas localidades é 9.
A rota direta mais longa entre duas localidades é entre 0 e 1, cuja distância é 10. Falso.

d) a rota mais curta partindo da localidade 3 e chegando na localidade 2 é 9.

Temos duas rotas possíveis:
* 3-4-0-2: distância 4+7+5 = 16
* 3-4-0-1-2: distância 4+7+10+2 = 23
Falso.

e) é possível ir e voltar de todas as localidades adjacentes.
É possível ir e voltar, porém por caminhos diferentes. Falso.

Gabarito: Letra B

Question 22

1. (FGV - 2015 – TJ-RO – Analista Judiciário - Análise de Sistemas)

Se fosse construído um índice de banco de dados do tipo “bitmap” para essa tabela, tendo o campo Curso como chave, o conteúdo desse índice seria:

a)
6 3
23 3
45 1
57 1
210 3
356 2
1210 1

b)
Física 1001100
Química 0100000
Matemática 0010011

c)
6 001
23 001
45 100
57 100
210 001
356 010
1210 100

d)
0011001100
0100100000
0010010011

e)
00000000110 Matemática
00000010111 Matemática
00000101101 Física
00000111011 Física
00011010010 Matemática
00101100100 Química
10010111010 Química

Answer 22

A questão solicita a criação de um índice usando bitmap da coluna curso.

Lembrando da aula teórica que a tabela bitmap terá como linhas os valores da coluna fonte do índice, ou seja, Física, Química e Matemática. As colunas do bitmap são os números das tuplas
(ROWID) .

O conteúdo do bitmap é o preenchimento de acordo com o valor de cada tupla original relativo à coluna fonte do índice. Construindo o bitmap para curso temos:

A resposta, portanto, é a letra B.

Gabarito: B

Question 23

9. (CEBRASPE/POLC AL/2023)

Julgue o próximo item, no que se refere a estruturas de controle de fluxo.

// codigo 1
i = 1
fim = 7
enquanto i < fim faça
escreva(i)
i = i + 1
fim enquanto
depois = i

// codigo 2
fim = 6
i = 0
enquanto i < fim faça
i = i + 1
escreva(i)

fim enquanto
depois = i

Considerando a estrutura precedente, é correto afirmar que o código 1 e o código 2 apresentam o mesmo resultado.

Answer 23

Temos dois loops Enquanto.

Ambos possuem a mesma estrutura - serão executados enquanto a variável i for menor que a variável fim (i < fim) e, a cada iteração, incrementarão o valor da variável i em 1 unidade.

Vamos analisar a saída de cada código.

Código 1:

Iremos fazer 6 laços (de i = 1 a i = 6), e, a cada laço, iremos:

• Escrever o valor de i
• Incrementá-lo em uma unidade

Então, os laços serão os seguintes:

• Laço 1 - i = 1:
  o escreva (i) → 1
  o i = i + 1 → i = 2
• Laço 2 - i = 2:
  o escreva(i) → 2
  o i = i + 1 → i = 3
• Laço 3 - i = 3:
  o escreva(i) → 3
  o i = i + 1 → i = 4
• Laço 4 - i = 4:
  o escreva(i) → 4
  o i = i + 1 → i = 5
• Laço 5 - i = 5
  o escreva(i) → 5
  o i = i + 1 → i = 6
• Laço 6 - i = 6
  o escreva(i) → 6
  o i = i + 1 → i = 7

No laço 6, quebramos a condição e o bloco Enquanto. As saídas dessa estrutura foram (1, 2, 3, 4, 5, 6).

Código 2:

Iremos também fazer 6 laços, de i = 0 a i = 5. Aqui a ordem da execução da função muda:

• Primeiro somamos 1 ao valor de i
• Depois escrevemos o valor de i
  Então, teremos os seguintes laços:
• Laço 1 - i = 0
  o i = i + 1 → i = 1
  o escreva(i) → 1
• Laço 2 - i = 1
  o i = i + 1 → i = 2
  o escreva(i) → 2
• Laço 3 - i = 2
  o i = i + 1 → i = 3
  o escreva(i) → 3
• Laço 4 - i = 3
  o i = i + 1 → i = 4
  o escreva(i) → 4
• Laço 5 - i = 4
  o i = i + 1 → i = 5
  o escreva(i) → 5
• Laço 6 - i = 5
  o i = i + 1 → i = 6
  o escreva(i) → 6
  A saída aqui será (1, 2, 3, 4, 5, 6).

Veja que temos a mesma saída - isso acontece pois a escrita do
valor da variável acontece antes do incremento no código 1, e depois do incremento no código
2. Sendo assim, correta a afirmativa.

Gabarito: Correto

Question 24

10. (VUNESP/TCM SP/2023)

Analise o algoritmo a seguir, apresentado na forma de uma
pseudolinguagem.

Início
[
Tipo MAT = matriz[1..3,1..3] de inteiros;
MAT: M;
Inteiro: i, j, X, Y;
X ← 0;
Y ← 0;
Para i de 1 até 3 faça
[
Para j de 1 até 3 faça
[
Se i = j
Então M[i,j] ← i + j + 1;
Senão M[i,j] ← i + 2*j + 1;
]
]
Para i de 1 até 3 faça
[
X ← X + M[i,i];
Y ← Y + M[1,i];
]
Imprima (X+Y);
] Fim.

Ao final do algoritmo é impressa a soma (X+Y) que é igual a

a) 29.
b) 30.
c) 31.
d) 32.
e) 33.

Answer 24

Em questões longas como essa, aconselho que analise o código com muita calma e cuidado, para entender a ordem de execução dos comandos.

Nessa questão, estamos executando um loop Para, visando preencher uma matriz 3x3.

Dentro desse loop, executamos outro Para que irá, de fato, preencher a lista. A interação de loops aninhados é a seguinte:

• Começamos a executar o loop externo com i = 1
• Executamos o loop interno de forma completa, com o j indo de 1 a 3
• Passamos para a execução do loop externo com i = 2, repetindo o processo, e para i = 3, repetindo o processo novamente

Então, como já sabemos quais valores começamos a execução do bloco mais interno do código,
vamos começar.

Laço 1 - i = 1; j = 1

Vamos executar um Se, que irá preencher:

• O elemento Mi, j com o valor i + j + 1, se i = j
• O elemento Mi, j com o valor i + 2*j + 1, caso contrário.

Como temos i = j no primeiro laço, caímos no bloco Se, então:

• M1, 1 = i + j + 1;
• M1, 1 = 1 + 1 + 1 = 3

Laço 2 - i = 1; j = 2

Agora, i =~ j, então caímos no bloco do senão. Então:
* M1, 2 = i + 2j + 1
* M1, 2 = 1 + 22 + 1 = 6

Laço 3 - i = 1; j = 3
Novamente, vamos ao bloco senão.

• M1, 3 = i + 2*j + 1
• M1, 3 = 1 + 2*3 + 1 = 8

Com isso encerramos o primeiro laço do loop externo, com i = 1.

Repetiremos esse processo pra
i = 2, e i = 3. Os resultados de cada iteração serão:

• Laço 3: M2, 1 = 5
• Laço 4: M2, 2 = 5
• Laço 5: M2, 3 = 9
• Laço 6: M3, 1 = 6
• Laço 7: M3, 2 = 8
• Laço 8: M3, 3 = 7

Com esses valores, conseguimos construir nossa matriz:

ÍNDICE 1 2 3
1 3 6 8
2 5 5 9
3 6 8 7

Bom, agora que temos a matriz, temos mais um loop para ser executado - e mais um loop Para, que vai de 1 até 3, ou seja, 3 iterações.

Nele, fazemos duas operações:

• Atribuímos incrementalmente o valor de M[i, i] à variável X
• Atribuímos incrementalmente o valor de M[1, i] à variável Y

Vamos resolver esses laços agora.

Laço 1 - i = 1:
* X = M1, 1
* X = 3
* Y = M[1, 1]
* Y = 3

Laço 2 - i = 2:
* X = X + M2, 2
* X = 3 + 5
* X = 8
* Y = Y + M1, 2
* Y = 3 + 6
* Y = 9

Laço 3 - i = 3:
* X = X + M3, 3
* X = 8 + 7
* X = 15
* Y = Y + M1, 3
* Y = 9 + 8
* Y = 17

Então, terminamos com X = 15 e Y = 17.

Por fim, finalmente (ufa), fazemos a soma dos valores
para encontrar a resposta:

X + Y = 15 + 17 = 32

Gabarito: Letra D

Question 25

14. (VUNESP/UNICAMP/2023) O programa a seguir, expresso na forma de uma pseudolinguagem (português estruturado), deve ser analisado e utilizado para responder às questões de números 23 e 24. Início Inteiro: a, b, c, i, M; a ← 0; b ← 2; c ← 4; M ← 10; Para i de 1 até 5 faça [ Se (a < b) Então [ a ← a + 1; c ← a + b; ]] M ← M + a + b - c; Imprima M; Fim. No programa, o número de vezes que a condição Se (a < b) dentro do loop Para... se mostra verdadeira é: a) 1 b) 2 c) 3 d) 4 e) 5

Answer 25

Temos um loop Para executado 5 vezes (de i = 1 até i = 5). A cada iteração, se a < b, faremos uma operação incremental em a, e atualizaremos o valor de c com o valor de a + b. Como para nossa análise só importa o valor de a e b, vamos ignorar as interações com a variável c. Vamos ver os laços: Laço 1 - i = 1; a = 0, b = 2 Caímos no bloco Se, então, teremos: * a = a + 1 * a = 0 + 1 = 1 Laço 2 - i = 2; a = 1; b = 2 Novamente, caímos no bloco Se. Teremos: * a = a + 1 * a = 1 + 1 = 2 A partir do laço 3, teremos a = b (2), então não teremos mais o valor Verdadeiro para a condicional Se (a < b). Assim, podemos afirmar que o número de vezes que a condição é considerada verdadeira é igual a 2. Gabarito: Letra B

Question 26

27. (CEBRASPE/Pref. Fortaleza/2023) Com relação a estruturas de controle, seleção, repetição e desvio, julgue o item a seguir. No algoritmo a seguir, o comando x = x + 10 é executado quatro vezes. x = 10; para (y = 40; y < 100; y = y + 16) x = x + 10; fim para

Answer 26

O Para inicia com a variável em 40, com o limite superior menor que 100, e incrementa o valor em 16 unidades a cada laço. Então, teremos execuções para y igual a 40, 56, 72 e 84. A próxima iteração seria com y = 100, que passa a não obedecer mais à condição de verificação (y < 100). Portanto, de fato, executamos o comando 4 vezes. Gabarito: Correto

Question 27

28. (CEBRASPE/Pref. Fortaleza/2023) Com relação a estruturas de controle, seleção, repetição e desvio, julgue o item a seguir. Se os valores a = 3, b = 4 e c = 8 forem entradas do algoritmo a seguir e o sistema no qual o algoritmo for executado utilizar números decimais com quatro casas de precisão, então a execução do referido algoritmo apresentará em tela o resultado 10.3923. sp = (a + b + c)/2; ar = sp*(sp - a)*(sp - b)*(sp - c); se (ar < 0) escreva (“Não é possível obter resultado.”); senão escreva (“Resultado: “); escreva(raiz_quadrada(ar)); fimse

Answer 27

Vamos desenvolver os cálculos. sp = (3 + 4 + 8)/2 = 15/2 = 7.5 ar = 7.5 * (7.5 - 3) * (7.5 - 4) * (7.5 - 8) = -59.0625 Como temos um valor de ar menor que 0 (ar < 0), executaremos o bloco Se, tendo como retorno o texto “Não é possível obter resultado”, e não o valor 10.3923. Gabarito: Errado

Question 28

29. (CEBRASPE/Pref. Fortaleza/2023) Com relação a estruturas de controle, seleção, repetição e desvio, julgue o item a seguir. Após executado, o algoritmo a seguir apresentará 720 como resultado final. função f(x) se (x == 0 ou x == 1) retorna 1; fimse retorna f(x - 1)*x fimfunção função func(a) se (a == 0) retorna 2 fimse retorna a + f(a - 1) fimfunção escreva(func(6));

Answer 28

Temos duas funções - uma função recursiva f(x) e outra função de ordem superior func(a). Estamos chamando primeiramente a função de ordem superior, com func(6). Então, vamos ver o que acontece. Como o parâmetro a = 6, vamos cair no bloco alternativo - vamos retornar a + f(a - 1), ou seja, a + (f5). Sendo assim, precisamos subir para a função f(x) e resolvê-la com x = 5. E nela, novamente, como não atendemos a condição do Se, vamos executar o retorno - f(x-1) * x Laço 1 - f(5) = f(4) * 5 Laço 2 - f(4) = f(3) * 4 Laço 3 - f(3) = f(2) * 3 Laço 4 - f(2) = f(1) * 2 Por fim, no laço 5 teremos f(1), e, como x == 1, caímos no bloco base - retornando 1. Como chegamos a um valor, podemos subir somando. Laço 5 - f(1) = 1 Laço 4 - f(2) = f(1) * 2 = 1 * 2 = 2 Laço 3 - f(3) = f(2) * 3 = 2 * 3 = 6 Laço 2 - f(4) = f(3) * 4 = 6 * 4 = 24 Laço 1 - f(5) = f(4) * 5 = 24 * 5 = 120 Então, encontramos que f(5) é igual a 120. Então é essa a resposta... só que não! Agora temos que voltar para a função que foi chamada inicialmente, a func, nós paramos a execução do bloco com a + f(5). Portanto, teremos a + 120 = 120 + 6 = 126. De toda a forma, a resposta não será 720 - portanto, a afirmativa está incorreta. Gabarito: Errado

Question 29

31. (CEBRASPE/Pref. Fortaleza/2023) Julgue o item que se segue, relativo a conceitos de avaliação de expressões. Após o algoritmo a seguir ser executado, o valor da variável soma1 será maior que o da variável soma2. vetor a[7]; real soma1, soma2; inteiro i; a = [1,3,9,27,81,243,729];} soma1 = 0; i = 0; enquanto (i < 7) faça soma1 = soma1 + a[i] i = i + 1 fim enquanto soma2 = 1 * (1-3^7)/(1-3) escreva(soma1) escreva(soma2)

Answer 29

A questão traz algumas variáveis, dentre elas um vetor a com 7 elementos. Vamos achar o valor de soma1 e soma2, para verificarmos o apontamento da afirmativa. Vamos começar com o soma1. O loop Enquanto irá somando o valor atual de soma1 com a respectiva posição no vetor. Então, como i = 0, e o aumento a cada laço é incremental, faremos 7 loops (de i = 0 até i = 6). Vamos ver o primeiro laço: Laço 1 - i = 0: soma1 = soma1 + a[0] soma1 = 0 + 1 = 1 Laço 2 - i = 1: soma1 = soma1 + a[1] soma1 = 1 + 3 = 4 Laço 3 - i = 2: soma1 = soma1 + a[2] soma1 = 4 + 9 = 13 Laço 4 - i = 3: soma1 = soma1 + a[3] soma1 = 13 + 27 = 40 Laço 5 - i = 4: soma1= soma1 + a[4] soma1 = 40 + 81 = 121 Laço 6 - i = 5 soma1 = soma1 + a[5] soma1 = 121 + 243 = 364 Laço 7 - i = 6 soma1 = soma1 + a[6] soma1 = 364 + 729 = 1093 Portanto, o valor final da variável soma1 é 1.093. Na hora da prova, se você tiver entendido a lógica - que estamos somando todos os valores do vetor - a resolução se torna muito mais rápido. Só iríamos somar os valores de a, e encontraríamos o mesmo valor. Agora, vamos para a soma2. soma2 = 1 * (1 - (3^7)) / (1-3) soma2 = 1 * (1 - 2187) / (-2) soma2 = 1 * (-2186) / (-2) soma2 = 1 * 1.093 soma2 = 1.093 Então, o valor de soma2 (1.093) é maior que o valor de soma1 (1.093). Sendo assim, afirmativa correta. Gabarito: Correto

Question 30

32. (VUNESP/TJM SP/2023) Analise o programa a seguir, apresentado na forma de uma pseudolinguagem (Português Estruturado). Início Inteiro: x, y, z, i; x ← 3; y ← 3; z ← 3; Para i de 1 até 6 faça [ Se (z = 3) Então [ x ← x+1; y ← y+2; z ← z-1; ] Senão [ z ← z+1; ] ] z ← x + y + z; Fim. O valor da variável z ao final da execução desse programa será: a) 15 b) 16 c) 17 d) 18 e) 19

Answer 30

Não deixe o tamanho da sintaxe te assustar. Encare com calma, linha por linha, para entender o que está acontecendo. Iniciamos o código declarando 3 variáveis do tipo inteiro, x, y e z - todas com o valor igual a 3. Em seguida, iniciamos um loop Para numa notação um pouco diferente do que vimos, mas basicamente estamos iniciando em 1, indo até 6 com incrementos de uma unidade - ou seja, seria como Para (i = 1, i <= 6; i++) - ou seja, 6 laços. O bloco de código executado a cada laço é um Se...então...senão. A condição Se é z = 3 e, como iniciamos o programa com z = 3, iniciaremos o bloco fazendo as operações elencadas no bloco Se. Vamos lá! Laço 1 - i = 1; z = 3 (bloco Se); x = x + 1 = 3 + 1; x = 4 y = y + 2 = 3 + 2; y = 5 z = z - 1 = 3 - 1; z = 2 <- como caímos em z diferente de 3, o próximo bloco será no senão. Laço 2 - i = 2; z = 2 (bloco Senão); z = z + 1 = 2 + 1; z = 3 Laço 3 - i = 3; z = 3 (Bloco Se) x = x + 1 = 4 +1; x = 5 y = y + 2 = 5 + 2; y = 7 z = z - 1 = 3 - 1; z = 2 Laço 4 - i = 4; z = 2 (bloco Senão) z = z + 1 = 2 + 1; z = 3 Laço 5 - i = 5; z = 3 (bloco Se) x = x + 1 = 5 + 1; x = 6 y = y + 2 = 7 + 2; y = 9 z = z - 1 = 3 - 1; z = 2 Laço 6 - i = 6; z = 2 (bloco Senão) z = z + 1 = 2 + 1; z = 3 Bom, fizemos os laços, e terminamos com os seguintes valores: x = 6 y = 9 z = 3 Por fim, temos uma nova atribuição de valor à variável z antes de finalizar o programa: z = x + y + z z = 6 + 9 + 3 = 18 Portanto, o valor final de Z será igual a 18. Gabarito: Letra D

Question 31

43. (SELECON/AMAZUL/2022) Na operação de soma dos números binários 10001010 + 01011111, o resultado será igual a: a) 00101011 b) 10010110 c) 00110101 d) 11101001

Answer 31

Precisamos converter os números binários para a base decimal, de forma que seja possível fazer a soma. Temos: * 10001010 = 21 + 23 + 27 = 138 * 01011111 = 20 + 21 + 22 + 23 + 24 + 26 = 95 Então, 95 + 138 = 233, que é expresso como 11101001 em base binária. Gabarito: Letra D

Question 32

59. (SS CENTEC/CENTEC/2022) Sendo que A=3, B=7, C=4 e D=B, marque a alternativa CORRETA de acordo com as afirmações abaixo. I. (B + A) <= C II. (A > C) AND (C <= D) III. (A+B) > 10 OR (A+B) = (C+D) IV. (A>=C) AND (D >= C) a) Apenas II, III e IV. b) Apenas, III e IV. c) Apenas IV. d) Todas afirmativas são verdadeiras. e) Nenhuma alternativa é verdadeira.

Answer 32

Vamos analisar cada item - e assinalar aqueles com retorno verdadeiro. I. (B + A) <= C Falso. B + A = 10; C = 4. Portanto, temos 10 ≤ 4 - que é falso. II. (A > C) AND (C <= D) Falso. Temos duas operações. (A > C), ou (3 > 4) tem valor FALSO, e (C <= D), ou (4 ≤ 8) tem valor VERDADEIRO. Como estamos operando com o E lógico (AND), ambos os lados precisariam ser verdadeiros para termos o retorno verdadeiro. III. (A+B) > 10 OR (A+B) = (C+D) Falso. ((A + B) > 10), ou (10 > 10) é FALSO, e ((A + B) = (C + D)), ou (10 = 7) também é FALSO. Como ambos os lados do operador OR (ou lógico) são falsos, a afirmação é falsa. IV. (A>=C) AND (D >= C) Falso. Temos (A >= C), ou (3 ≥ 4), que é FALSO, e ( D >= C), ou (7 ≥ 4), que é VERDADEIRO. Porém, na disjunção (AND, ou E lógico), precisamos de ambos os lados verdadeiros para termos um retorno verdadeiro - sendo assim, a afirmação é falsa. Pela análise, concluímos que nenhuma alternativa é verdadeira. Gabarito: Letra E

Question 33

real c, b, d; real x, y; c = 5; b = 8; d = 3; x = (c < b) ou (b < d) e (c < d); y = ((c < b) ou (b < d)) e (c < d); escreva(x); escreva(y); Com base no algoritmo precedente, julgue o item a seguir, relativo a operadores e expressões. Após a execução desse algoritmo, os valores das variáveis x e y serão diferentes.

Answer 33

Questão interessante. Temos 5 variáveis (c, b, d, x, y), todas do tipo real (números positivos). As variáveis c, b e d são declaradas de forma direta, com os valores 5, 8 e 3, e as variáveis X e Y vão receber o valor resultante da operação lógica contida nelas. Um detalhe importante, como estamos trabalhando com as variáveis x e y do tipo real, apesar de termos uma comparação lógica, o valor de saída será um número - 0 se Falso, 1 se Verdadeiro. Vamos realizar as duas operações. x = (c < b) ou (b < d) e (c < d) Basicamente, estamos fazendo o seguinte: x = (5 < 8) ou (8 < 3) e (5 < 3); x = (V) ou (F) e (F) Para resolvermos, precisamos saber a ordem de execução das operações lógicas. As linguagens podem variar, mas, de forma geral, temos NÃO → E → OU. Então, faríamos: x = (V) ou ((F) e (F)) = (V) ou (F); x = 1 (Verdadeiro). y = ((c < b) ou (b < d)) e (c < d) Agora temos um parênteses - e ele sempre terá precedência. Executaremos o lado do “OU” antes e, depois, compararemos com o outro lado da equação. y = ((V) ou (F)) e (F) = (V) e (F); y = 0 (Falso). Como x (1) e y (0) são diferentes, a afirmativa está incorreta. Gabarito: Falso

Question 34

(FGV/CÂMARA DOS DEPUTADOS/2023) Analise as operações bitwise do JavaScript, exibidas a seguir. 4 & 1 7 | 2 ~ -5 9 >> 2 9 >>> 1 Os valores de cada uma dessas expressões, na ordem, são: a) 0; 7; 5; 1; 2. b) 1; 9; 5; 1; 2. c) 0; 7; 4; 2; 4. d) 0; 9; 4; 0; 4. e) 1; 1; -5; 4; 2.

Answer 34

Apesar da questão ser implementada em linguagem (JavaScript), você não deve ter dificuldades para resolvê-la, já que esse tipo de operação independe de linguagem. Vamos lá! 1. 4 & 1 Primeiro, convertemos 4 e 1 para bits, ficando com 0100 & 0001. Agora, comparamos: * 0 & 0 = 0 * 1 & 0 = 0 * 0 & 0 = 0 * 0 & 1 = 0 Resultado 0000 = 0 2. 7 | 2 Convertendo-os para binários, ficamos com 0111 e 0010. * 0 | 0 = 0 * 1 | 0 = 1 * 1 | 1 = 1 * 1 | 0 = 1 Resultado 0111 = 7 3. ~ -5 Vamos aplicar a fórmula, já que é a forma mais prática de resolvermos a questão. Lembrem: * ~X = - (X+1) * ~ (-5) = - (-5+1) * ~ (-5) = - (-4) * ~ (-5) = 4 Resultado = 4 4. 9 >> 2 Essa envolve um deslocamento bitwise de 2 casas à direita. 9, em binário, é 1001. Deslocando: * 1001 >> 2 = 0010 * Portanto, temos 0010 = 2 5. 9 >>> 1 Como falei para vocês, operações zero-fill com números positivos não mudam nada. Assim, vamos deslocar 1001 uma casa para a direita, preenchendo com 0s. * 1001 >> 2 = 0100 Portanto, temos 0100 = 4 Sendo assim, ficamos com 0, 7, 4, 2 e 4 – correta a letra C. Gabarito: Letra C

Question 35

11. (CESPE – MPE-CE – 2020) Com base na linguagem de programação Java, julgue o item a seguir. O código public class mpce { public static void main(String[] args) { int[][] num = { {3, 5}, {9, 7} }; for (int i = 0; i < num.length; ++i) { for(int j = 0; j < num[i].length; ++j) { System.out.println(num[i][j]); } } } } apresentará, quando executado, o resultado a seguir. 3 5 7 9

Answer 35

O código apresentado tem a seguinte estrutura: ```java public class mpce { public static void main(String[] args) { int[][] num = { {3, 5}, {9, 7} }; for (int i = 0; i < num.length; ++i) { for (int j = 0; j < num[i].length; ++j) { System.out.println(num[i][j]); } } } } ``` O código utiliza uma matriz bidimensional `int[][] num = { {3, 5}, {9, 7} };`. Ou seja, `num` contém duas "linhas", sendo a primeira `{3, 5}` e a segunda `{9, 7}`. O primeiro laço `for (int i = 0; i < num.length; ++i)` percorre as duas linhas da matriz (índices 0 e 1). Para cada linha, o segundo laço `for(int j = 0; j < num[i].length; ++j)` percorre os elementos dentro de cada linha. O resultado será impresso na seguinte ordem: - Primeiro, os elementos da primeira linha: `3` e `5`. - Depois, os elementos da segunda linha: `9` e `7`. Portanto, a saída correta seria: ``` 3 5 9 7 ``` A afirmação do enunciado está incorreta, já que ele afirma que a saída seria: ``` 3 5 7 9 ``` Ou seja, a ordem dos números `7` e `9` está invertida na afirmação apresentada. Gabarito: Errado

Question 36

12. (CESPE – MPE-CE – 2020) Com base na linguagem de programação Java, julgue o item a seguir. O código public class mpce { public static int Funcao(int num, int resultado){ if(num<1) return resultado; resultado+=(num%10); return Funcao(num/10, resultado); } public static void main(String[] args) { int res = Funcao(17, 0); System.out.println("O resultado é: " + res); } } apresentará a seguinte saída ao ser executado. O resultado é: 8

Answer 36

Analisando o código fornecido: ```java public class mpce { public static int Funcao(int num, int resultado) { if(num < 1) return resultado; resultado += (num % 10); // Soma o último dígito de num ao resultado return Funcao(num / 10, resultado); // Chama recursivamente com o número sem o último dígito } public static void main(String[] args) { int res = Funcao(17, 0); // Chama a função com o número 17 e resultado inicial 0 System.out.println("O resultado é: " + res); } } ``` Explicação do código: 1. **Funcao(17, 0)**: - `num = 17`, `resultado = 0` - Soma o último dígito de 17, ou seja, `17 % 10 = 7`, então `resultado = 0 + 7 = 7`. - Chama recursivamente `Funcao(17 / 10, 7)` -> `Funcao(1, 7)`. 2. **Funcao(1, 7)**: - `num = 1`, `resultado = 7` - Soma o último dígito de 1, ou seja, `1 % 10 = 1`, então `resultado = 7 + 1 = 8`. - Chama recursivamente `Funcao(1 / 10, 8)` -> `Funcao(0, 8)`. 3. **Funcao(0, 8)**: - `num = 0`, a função retorna o valor de `resultado = 8`. Resultado: O código soma os dígitos do número 17 (7 + 1), e o resultado final é 8. Portanto, a saída será: ``` O resultado é: 8 ``` A afirmação está **correta**.

Question 37

13. (CESPE – TJPA – 2020) class GeraNumeros { public static void main (String args []) { int num; num = 36; for(int i=0; i < num; i++) { if(i*i >= num) break; System.out.print(i + “ ”); } } } Assinale a opção que apresenta corretamente a saída gerada pelo código Java precedente. a) 36 b) 1 2 3 4 5 6 c) 1 2 3 4 5 d) 0 1 2 3 4 5 e) 0 1 2 3 4 5 6

Answer 37

Vamos analisar o código: ```java class GeraNumeros { public static void main (String args []) { int num; num = 36; for (int i = 0; i < num; i++) { if (i * i >= num) break; // Encerra o loop se i * i for maior ou igual a num System.out.print(i + " "); } } } ``` Análise: - O código inicia com `num = 36` e o loop `for` começa com `i = 0`. - Para cada valor de `i`, ele verifica a condição `i * i >= num`. - Se `i * i` for maior ou igual a `num`, o loop é interrompido. - Caso contrário, o valor de `i` é impresso. ### Iterações: 1. `i = 0`, `i * i = 0 * 0 = 0` (não quebra o loop), imprime `0`. 2. `i = 1`, `i * i = 1 * 1 = 1` (não quebra o loop), imprime `1`. 3. `i = 2`, `i * i = 2 * 2 = 4` (não quebra o loop), imprime `2`. 4. `i = 3`, `i * i = 3 * 3 = 9` (não quebra o loop), imprime `3`. 5. `i = 4`, `i * i = 4 * 4 = 16` (não quebra o loop), imprime `4`. 6. `i = 5`, `i * i = 5 * 5 = 25` (não quebra o loop), imprime `5`. 7. `i = 6`, `i * i = 6 * 6 = 36` (quebra o loop, pois `i * i >= num`). O loop para antes de imprimir `6`, então a sequência de saída é: `0 1 2 3 4 5`. Resposta correta: **d) 0 1 2 3 4 5**. Gabarito: D

Question 38

5. (FGV – MPE-AL – 2018) Analise o código Java a seguir. public class Exemplo { public static void main(String[] args) { int a = 4, b = 16; String out = (a^b)==0 ? "Sim": (a & b)!=0 ? "Talvez" : "Não"; System.out.println(out); } } A execução do código acima produzirá a) um erro de compilação. b) um erro de execução. c) a linha “Sim”. d) a linha “Não”. e) a linha “Talvez”.

Answer 38

Vamos analisar o código fornecido: ```java public class Exemplo { public static void main(String[] args) { int a = 4, b = 16; String out = (a^b) == 0 ? "Sim" : (a & b) != 0 ? "Talvez" : "Não"; System.out.println(out); } } ``` Explicação do código: 1. **Operadores Bitwise:** - `a^b`: O operador `^` é o operador **XOR** (OU exclusivo) bit a bit. Ele compara os bits correspondentes de `a` e `b` e retorna 1 quando os bits são diferentes e 0 quando são iguais. - `a = 4` em binário é `0100`. - `b = 16` em binário é `10000`. - `a^b` faz a operação XOR bit a bit entre `0100` e `10000`, resultando em `10100` (que é 20 em decimal). - Portanto, `(a^b)` é 20, que não é igual a 0. 2. Como `(a^b) == 0` é **falso**, a primeira parte da expressão condicional (`"Sim"`) é ignorada, e a próxima condição é avaliada. 3. **a & b**: O operador `&` é o operador **AND** bit a bit, que compara os bits correspondentes de `a` e `b` e retorna 1 quando ambos os bits são 1. - `a = 4` em binário é `0100`. - `b = 16` em binário é `10000`. - `a & b` faz a operação AND bit a bit entre `0100` e `10000`, resultando em `00000` (que é 0 em decimal). - Portanto, `(a & b) != 0` é **falso**. 4. Como ambas as condições são falsas, a última parte da expressão condicional será executada, que é `"Não"`. Resultado: A linha impressa será **"Não"**. Resposta correta: **d) a linha “Não”.**

Question 39

2. (CESGRANRIO – Banco do Brasil – 2023) Sejam as seguintes classes Java, que ocupam arquivos separados: public class CAx { protected int a; protected int b; public CAx() { a*=2; b*=3; } { a=1; b=2; } public int op1(int x) { return op2(x)+op3(x)+b; } public int op2(int x) { return x+a; } public static int op3(int x) { return x*2; } } public class CBy extends CAx { protected int a; public CBy() { a+=3; b+=3; } public int op2(int x) { return x-a; } public static int op3(int x) { return x*3; } } public class Main { public static void main(String[] args) { CAx o=new CBy(); System.out.println(o.op1(2)); } } O que será exibido no console quando o método main for executado? a) 10 b) 12 c) 14 d) 18 e) 20

Answer 39

Vamos analisar passo a passo a execução do código para entender por que o resultado é 12: No método main, é criado um objeto o da classe CBy, mas é referenciado como CAx. Isso é permitido devido ao polimorfismo, onde uma referência de uma superclasse pode apontar para um objeto de uma subclasse. Durante a criação do objeto o, primeiro o construtor da classe pai (CAx) é chamado. Esse construtor inicializa os atributos a e b com 1 e 2, respectivamente, e depois os multiplica por 2 e 3. Então, ao final desse construtor, a é 2 e b é 6. Em seguida, o construtor da classe filha (CBy) é chamado. Nesse construtor, o atributo a é incrementado em 3, tornando-o 5. O atributo b não é alterado neste construtor. O método op1(2) é chamado no objeto o. Este método primeiro calcula op2(2), que é 2 - 5 = -3. Em seguida, calcula op3(2), que é 2 * 3 = 6. Finalmente, soma op2(2), op3(2) e b, que é 6 + (-3) + 6 = 9. Portanto, o método op1(2) retorna 9. Este valor é então impresso no console pela linha System.out.println(o.op1(2));. Portanto, a resposta correta é b) 12. Gabarito: Letra B

Question 40

3. (CESGRANRIO – Banco do Brasil – 2023) Considere as seguintes classes Java, que ocupam arquivos separados: public class Pa { String x,y,z; String r="vazio"; public Pa(String s1,String s2, String s3) throws Exception { x=s1; y=s2; z=s3; try { if(x==null || y==null || z==null) throw new Exception(); } catch(Exception e) { z="a"; throw e; } finally { if(x==null) x="***"; if(y==null) y="***"; if(z==null) z="***"; } } public String get() { return r; } } public class Qb extends Pa { public Qb(String s1,String s2, String s3) throws Exception { super(s1,s2,s3); r=x+y+z; } } public class Main { public static void main(String[] args) { Pa o=null; try { o=new Qb("a"," ","c"); } catch (Exception e) { System.out.print(“***Erro***“); } finally { if(o!=null) System.out.print(o.get()); } } } O que será exibido no console quando o método main for executado? a) ac b) a***a c) a***c d) ***Erro*** e) vazio

Answer 40

Quando o método main for executado, o que será exibido no console depende de como o fluxo de execução ocorre, considerando as exceções e os blocos try-catch-finally. Vamos analisar o código passo a passo: No método main, um objeto o da classe Qb (que é uma subclasse de Pa) é inicializado com os parâmetros "a", " ", e "c". Durante a inicialização do objeto o, o construtor da classe Qb é chamado, que por sua vez chama o construtor da classe Pa através do super(s1, s2, s3). No construtor da classe Pa, os valores dos parâmetros x, y, e z são atribuídos. Em seguida, é verificado se algum deles é null. Como y é " ", não é null, mas z é null, então o bloco catch é executado. Dentro do bloco catch, z é alterado para "a", e então a exceção é relançada. No bloco finally, x, y e z são verificados novamente. x e y não são null, mas z é null, então é atribuído o valor "***" a z. De volta ao construtor da classe Qb, r é atribuído concatenando x, y, e z. Portanto, r se torna "a a". Como a exceção foi lançada e não foi tratada no bloco try-catch em main, o programa não imprime ***Erro***, pois o fluxo de execução foi interrompido. No bloco finally, o método get() é chamado no objeto o, que tem o valor de r, que é "a a". Portanto, "a a" é impresso no console. Assim, a resposta correta é: A) "ac". Gabarito: Letra A

Question 41

7. (CESGRANRIO - Transpetro - 2023) Sejam as seguintes classes Java, que ocupam arquivos separados: public class L1 { int a=1, b=1, c=1; public L1() { a *= 2; b *= 2; c *= 2; } public int opA(int x, int y) { return a + b + c - opA(x) + opA(y); } public int opA(int x) { return x + 5; } { a++; b--; } } public class L2 extends L1 { public L2() { c+=2; } public int opA(int x, double y) { return a + b + c + opA(x)+ opA((int)y); } public static void main(String[] args) { L2 o=new L2(); System.out.println(o.opA(2,3)); } } O que será exibido no console quando o método main for executado? a) 6 b) 7 c) 9 d) 19 e) 21

Answer 41

As variáveis a, b e c na classe L1 são inicializadas com o valor 1. O bloco de inicialização de L1 incrementa a e decrementa b, resultando em a = 2 e b = 0. O construtor de L1 é chamado, multiplicando cada variável por 2: a = 4, b = 0 e c = 2. Na classe L2, o construtor incrementa c para c = 4. O método opA da classe L2 é chamado com os parâmetros 2 e 3. O método opA em L1 é chamado duas vezes recursivamente, uma vez para cada parâmetro. Na primeira recursão, o valor de x é 2. O método retorna x + 5 = 7. Na segunda recursão, o valor de y é convertido para int (3) e o método retorna y + 5 = 8. O método opA em L1 retorna a + b + c - opA(x) + opA(y). Substituindo os valores, obtemos: 4 + 0 + 4 - 7 + 8 = 9. Gabarito: Letra C

Question 42

16. (CESGRANRIO – Banco do Brasil - 2021) As classes Java a seguir são públicas e ocupam arquivos separados. public class Tst { int ini=0,fim=25; void print() { System.out.println(ini+fim); } { ini=fim%7; fim=ini*3; } Tst(int a, int b) { ini+=a; fim+=b; } { ini/=2; fim+=10; } } public class Main { public static void main(String[] args) { new Tst(4, -4).print(); } } O que será exibido no console quando o método main for executado? a) 0 b) 10 c) 24 d) 25 e) 33

Answer 42

Pessoal, as variáveis ini e fim são inicializadas com os valores 0 e 25, respectivamente. O primeiro bloco de inicialização é executado antes do construtor. O valor de ini é definido como o resto da divisão de fim por 7 (25 % 7 = 4). O valor de fim é definido como o produto de ini por 3 (4 * 3 = 12). Já, o segundo bloco é executado após o construtor em que o valor de ini é dividido por 2 (4 / 2 = 2). e após, o valor de fim é incrementado em 10 (12 + 10 = 22). Após, o construtor da classe Tst recebe dois parâmetros, a e b. O valor de ini é incrementado em a (2 + 4 = 6). E após, o valor de fim é incrementado em b (22 - 4 = 18). O método print é chamado no objeto new Tst(4, -4), este método imprime a soma de ini e fim (6 + 18 = 24). Por fim, o valor 24 será exibido no console. Assim, temos o nosso gabarito: c) Correta. O valor de ini e fim é 24. Gabarito: Letra C