Desenvolvimento (Code + Calc) Flashcards
- (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
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
- (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
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
- (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.
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
- (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
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
- (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
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
- (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
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
- (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
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
- (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.
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
- (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.
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:
- 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.
- Comparamos 23 com a raiz do lado esquerdo, que é 56. Como 23 é menor que 56, seguimos para o lado esquerdo da árvore.
- Comparamos 23 com a raiz do lado esquerdo, que é 35. Como 23 é menor que 35, seguimos para o lado esquerdo da árvore.
- 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.
- Comparamos 12 com a raiz do lado esquerdo, que é 56. Como 12 é menor que 56, seguimos para o lado esquerdo da árvore.
- 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.
- 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.
- 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:
- Comparamos 71 com a raiz, que é 74. Como 71 é menor que 74, seguimos para o lado esquerdo da árvore.
- 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.
- Comparamos 86 com a raiz do lado esquerdo, que é 56. Como 86 é maior que 56, seguimos para o lado esquerdo da árvore.
- Comparamos 86 com a raiz do lado esquerdo, que é 35. Como 86 é maior que 35, seguimos para o lado esquerdo da árvore.
- 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
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
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
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.
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
- (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.
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
- (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
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.
- (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
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
- (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.
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
- (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.
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
- (CESPE - 2009 – ANAC - Analista de Sistemas)
Uma árvore binária completa até o nível 10 tem 2.047 nós.
Se possui 10 níveis, possui [2^(d+1)] -1 : 2047 nós!!
Gabarito: Correto
- (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.
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
- (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
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
- (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.
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
- (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.
É 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
- (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
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
- (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.
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
- (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.
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
- (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
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
- (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
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
- (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
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
- (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));
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
- (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)
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
- (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
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
- (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
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
- (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.
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
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.
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
(FGV/CÂMARA DOS DEPUTADOS/2023) Analise as operações bitwise do JavaScript, exibidas a
seguir.
4 & 1
7 | 2
~ -5
9»_space; 2
9»_space;> 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.
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á!
- 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
- 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
- ~ -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
- 9»_space; 2
Essa envolve um deslocamento bitwise de 2 casas à direita. 9, em binário, é 1001.
Deslocando:
* 1001»_space; 2 = 0010
* Portanto, temos 0010 = 2
5. 9»_space;> 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»_space; 2 = 0100
Portanto, temos 0100 = 4
Sendo assim, ficamos com 0, 7, 4, 2 e 4 – correta a letra C.
Gabarito: Letra C
- (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
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
- (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
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:
-
Funcao(17, 0):
-
num = 17,resultado = 0 - Soma o último dígito de 17, ou seja,
17 % 10 = 7, entãoresultado = 0 + 7 = 7. - Chama recursivamente
Funcao(17 / 10, 7)->Funcao(1, 7).
-
-
Funcao(1, 7):
-
num = 1,resultado = 7 - Soma o último dígito de 1, ou seja,
1 % 10 = 1, entãoresultado = 7 + 1 = 8. - Chama recursivamente
Funcao(1 / 10, 8)->Funcao(0, 8).
-
-
Funcao(0, 8):
-
num = 0, a função retorna o valor deresultado = 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.
- (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
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 = 36e o loopforcomeça comi = 0. - Para cada valor de
i, ele verifica a condiçãoi * i >= num.- Se
i * ifor maior ou igual anum, o loop é interrompido. - Caso contrário, o valor de
ié impresso.
- Se
-
i = 0,i * i = 0 * 0 = 0(não quebra o loop), imprime0. -
i = 1,i * i = 1 * 1 = 1(não quebra o loop), imprime1. -
i = 2,i * i = 2 * 2 = 4(não quebra o loop), imprime2. -
i = 3,i * i = 3 * 3 = 9(não quebra o loop), imprime3. -
i = 4,i * i = 4 * 4 = 16(não quebra o loop), imprime4. -
i = 5,i * i = 5 * 5 = 25(não quebra o loop), imprime5. -
i = 6,i * i = 6 * 6 = 36(quebra o loop, poisi * 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
- (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”.
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:
-
Operadores Bitwise:
-
a^b: O operador^é o operador XOR (OU exclusivo) bit a bit. Ele compara os bits correspondentes deaebe retorna 1 quando os bits são diferentes e 0 quando são iguais.-
a = 4em binário é0100. -
b = 16em binário é10000. -
a^bfaz a operação XOR bit a bit entre0100e10000, resultando em10100(que é 20 em decimal). - Portanto,
(a^b)é 20, que não é igual a 0.
-
-
- Como
(a^b) == 0é falso, a primeira parte da expressão condicional ("Sim") é ignorada, e a próxima condição é avaliada. -
a & b: O operador
&é o operador AND bit a bit, que compara os bits correspondentes deaebe retorna 1 quando ambos os bits são 1.-
a = 4em binário é0100. -
b = 16em binário é10000. -
a & bfaz a operação AND bit a bit entre0100e10000, resultando em00000(que é 0 em decimal). - Portanto,
(a & b) != 0é falso.
-
- 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”.
- (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
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
- (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) aa
c) ac
d) Erro
e) vazio
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
- (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
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
- (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
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
