Colaborar - Av - Subst 2 - Algoritmos e Programação Estruturada

Prévia do material em texto

6/4/22, 9:18 PM Colaborar - Av - Subst. 2 - Algoritmos e Programação Estruturada
https://colaboraread.com.br/aluno/avaliacao/index/3071235702?atividadeDisciplinaId=12925039 1/9
 Algoritmos e Programação Estruturada (/alu…
Av - Subst. 2 - Algoritmos e Programação Estruturada
  
(/notific
Informações Adicionais
Período: 31/05/2022 00:00 à 04/06/2022 23:59
Situação: Cadastrado
Pontuação: 600
Protocolo: 746344429
Avaliar Material
1) Um dos problemas mais comuns para solucionar com pilhas são os labirintos. Estes são desafios criados como problematização de estrutura de
dados. As pilhas podem ser aplicadas também no uso de algoritmos de Backtracking, que consiste em criar marcações para onde o algoritmo pode
retornar. Em um labirinto, por exemplo, para encontrar um caminho correto, pode-se andar pelo labirinto até encontrar uma divisão nesse caminho.
Assim, adiciona-se a posição onde a divisão ocorre, junto ao caminho escolhido na pilha, e segue-se por ele. Caso o caminho escolhido não possua uma
saída, é removido o ponto anterior da pilha, voltando ao último ponto em que o labirinto se dividiu, e recomeça-se por um outro caminho ainda não
escolhido, adicionando na pilha o novo caminho. O algoritmo de Backtracking pode ser aplicado também como operação de desfazer. Baseado no
algoritmo de Backtracking, complete as lacunas da asserção a seguir:
 
Considerando o contexto apresentado, complete as lacunas a seguir:
Para implementar a operação de Backtracking, as ações são ____________ em ____________ e, caso a ____________ seja realizada, o estado anterior do
sistema pode ser ____________, ou a ação ____________ pode ser executada.
Assinale a alternativa que completa corretamente as lacunas:
https://colaboraread.com.br/aluno/timeline/index/3071235702?ofertaDisciplinaId=1740469
https://colaboraread.com.br/notificacao/index
javascript:void(0);
6/4/22, 9:18 PM Colaborar - Av - Subst. 2 - Algoritmos e Programação Estruturada
https://colaboraread.com.br/aluno/avaliacao/index/3071235702?atividadeDisciplinaId=12925039 2/9
a)
b)
c)
d)
e)
a)
b)
c)
d)
e)
2)
3)
Alternativas:
armazenadas / uma pilha / operação de refazer / restaurado / realizada.
aplicadas / uma pilha / operação de desfazer / eliminado / contrária à realizada.
armazenadas / uma pilha / operação de desfazer / restaurado / contrária à realizada. Alternativa assinalada
armazenadas / várias pilhas / operação de desfazer / eliminado / realizada.
aplicadas / uma pilha / operação de refazer / restaurado / contrária à realizada.
Uma pilha é uma estrutura de dados do tipo LIFO (Last in, First out), ou seja, na qual o último elemento a entrar é o primeiro a sair. Assim, nos
elementos que ainda permanecem, o que está no topo da pilha será o primeiro a ser removido.
Neste contexto, julgue as afirmações que se seguem.
I. Uma estrutura de pilha, devem ser implementadas duas operações básicas: empilhar um novo elemento e desempilhar um elemento.
II. A operação de empilhar um novo elemento tem a função de inserir um elemento na pilha, sendo definida na programação em C++ como
push_pilha( ).
III. A operação de desempilhar tem a função de remover um elemento do topo da pilha, sendo utilizada na programação em C++ como pop_pilha( ).
É correto apenas o que se afirma em:
Alternativas:
I.
II.
III.
I e II.
I, II e III. Alternativa assinalada
Filas e Pilhas são estruturas usualmente implementadas através de listas, restringindo a política de manipulação dos elementos da lista.
 
6/4/22, 9:18 PM Colaborar - Av - Subst. 2 - Algoritmos e Programação Estruturada
https://colaboraread.com.br/aluno/avaliacao/index/3071235702?atividadeDisciplinaId=12925039 3/9
a)
b)
c)
d)
e)
 
Podemos destacar as seguintes características entre Pilhas e Filas:
 
I. Pilhas e Filas são estruturas de dados com alocação dinâmica de memória, são Listas Encadeadas (ou Ligadas).
II. Ao implementar mecanismos de inserção e remoção de elementos da Lista Encadeada (ou Ligada) pode-se definir se a Lista comporta-se como
uma Fila ou como uma Pilha.
III. Tanto uma Pilha como a Fila podem ser implementadas por meio de uma Lista Encadeada ou de um Vetor (Array).
IV. Enquanto a Fila obedece ao princípio FIFO, uma Pilha é manipulada pelo princípio LIFO.
Análise as afirmativas e escolha a alternativa correta referente as afirmativas:
Alternativas:
Somente a afirmativa I está correta.
Somente as afirmativas II e III estão corretas.
Somente as afirmativas II e IV estão corretas. Alternativa assinalada
Somente as afirmativas I, III e IV estão corretas.
As afirmativas I, II, III e IV estão corretas.
6/4/22, 9:18 PM Colaborar - Av - Subst. 2 - Algoritmos e Programação Estruturada
https://colaboraread.com.br/aluno/avaliacao/index/3071235702?atividadeDisciplinaId=12925039 4/9
4) É importante realizar um fluxograma para entender como pode funcionar a Fila Circular para resolver o problema de processos, e a partir deste
fluxograma, criar o algoritmo para execução da solução.
 
Devido ao seu grande conhecimento em processos, um programador foi contratado por uma grande empresa de desenvolvimento de sistemas para
realizar a implementação de uma fila de processos em um sistema operacional.
 
Considerando o contexto apresentado, avalie as seguintes asserções e a relação proposta entre elas.
 
I. Aplica-se o algoritmo abaixo:
#include <stdio.h>
#include<stdlib.h>
#include <time.h> /* Declaração das funções de horas */
 
#define N 10
struct filacirc {
int tam, ini, fim; int vet[N];
};
typedef struct filacirc FilaCirc;
 
void inicia_fila (FilaCirc *f){
f -> tam = 0; f -> ini = 1; f -> fim = 0;
} 
 
void insere_fila (FilaCirc* f, char elem)
{
 if (f -> tam == N - 1)
 {
 printf("A fila esta cheia\n"); 
6/4/22, 9:18 PM Colaborar - Av - Subst. 2 - Algoritmos e Programação Estruturada
https://colaboraread.com.br/aluno/avaliacao/index/3071235702?atividadeDisciplinaId=12925039 5/9
 } else
 {
 f -> fim = (f -> fim % (N - 1)) + 1;
 f -> vet[f -> fim] = elem;
 f -> tam++;
 }
}
 
int fila_vazia (FilaCirc* f){
 return (f -> tam == 0); }
 
int remove_fila (FilaCirc* f)
{
 if (fila_vazia(f))
 {
 printf("Fila vazia\n");
 } else {
 f -> ini = (f -> ini % (N-1)) + 1; f -> tam--;
 }
 }
 
int main ( )
{
 FilaCirc* f; char processo[20];
 int tempo, tmpGasto;
 clock_t tInicio, tFim; /* Declaração de variável do tipo hora */
 printf(“\n Informe o tempo do processo em execução: \n”);
6/4/22, 9:18 PM Colaborar - Av - Subst. 2 - Algoritmos e Programação Estruturada
https://colaboraread.com.br/aluno/avaliacao/index/3071235702?atividadeDisciplinaId=12925039 6/9
 scanf(“%d”, &tempo);
 tInicio = clock(); /* Inicia o relógio */
 while (f -> tam < N - 1)
 { 
 insere_fila(f, processo);
 }
 while (f -> tam <= N - 1)
 { 
 tFim = clock(); /* Finaliza o relógio */
 tmpGasto = ((int) (tFim – tInicio)); /* Calcula o tempo gasto */
 if (tempo <= tmpGasto)
 { /* Se o tempo for menor ou igual ao tempo gasto, remove da fila */
 remove_fila(f);
 } else
 {
 printf("Processando...");
 }
 }
 system(“Pause”);
}
 
PORQUE
 
II. A implementação do algoritmo em questão é uma das formas possíveis de solucionar o problema de requisições nos processos em execução, com
base no tempo limite para cada processo executar, e garantir o funcionamento do sistema operacional de uma empresa, onde neste é verificado o
tempo limite de cada processo e assim que o tempo esgotar, o sistema irá remover o processo da fila e passar para o próximo processo.
A respeito dessas asserções, assinale a alternativa correta.
6/4/22, 9:18 PM Colaborar - Av - Subst. 2 - Algoritmos e Programação Estruturada
https://colaboraread.com.br/aluno/avaliacao/index/3071235702?atividadeDisciplinaId=129250397/9
a)
b)
c)
d)
e)
5)
Alternativas:
as asserções I e II são proposições verdadeiras, mas a II não é uma justificativa da I.
a asserção I é uma proposição verdadeira, e a II é uma proposição falsa.
as asserções I e II são proposições verdadeiras, e a II é uma justificativa da I. Alternativa assinalada
a asserção I é uma proposição falsa, e a II é uma proposição verdadeira.
as asserções I e II são proposições falsas.
Conforme Drozdek (2016), em uma Fila Circular, o conceito de circularidade se baseia quando o último elemento da fila está na última posição do
vetor, e é adjacente à primeira.
 
Uma Fila Circular utiliza menos instruções a serem executadas, podendo ser mais adequada e eficiente na utilização de programação.
 
Na coluna da direita apresenta-se alguns códigos que implementam funções para utilização da Fila Circular, já na coluna da direita apresentam-se seus
respectivos nomes.
 
I) void ________________ (FilaCirc *f)
{
   f -> tam = 0;
   f -> ini = 1;
   f -> fim = 0;
}
insere_fila 
6/4/22, 9:18 PM Colaborar - Av - Subst. 2 - Algoritmos e Programação Estruturada
https://colaboraread.com.br/aluno/avaliacao/index/3071235702?atividadeDisciplinaId=12925039 8/9
II) void ____________ (FilaCirc* f, char elem)
{
    if (f -> tam == N - 1)
         { /* Verifica se a Fila está completa */
                printf("A fila esta cheia\n");
         } else { /* Caso a Fila não esteja completa, inserimos o elemento */
                      f -> fim = (f -> fim % (N - 1)) + 1;
                      f -> vet[f -> fim] = elem; f -> tam++;
                   }
} 
inicia_fila
III) int ___________ (FilaCirc* f)
{
        return (f -> tam == 0); /* Retorna verdadeiro se a Fila estiver vazia */
 
} 
remove_fila 
IV) char ____________ (FilaCirc* f)
{
   if (fila_vazia(f))
        { /* Verifica se a Fila está vazia */
           printf("Fila vazia\n");
        } else { /* Caso a Fila contenha elemento, é removido o primeiro */
                    f -> ini = (f -> ini % (N-1)) + 1;
                    f -> tam--;
                  }
}   
fila_vazia
Agora assinale a alternativa que contém a sequência correta da associação entre as colunas.
6/4/22, 9:18 PM Colaborar - Av - Subst. 2 - Algoritmos e Programação Estruturada
https://colaboraread.com.br/aluno/avaliacao/index/3071235702?atividadeDisciplinaId=12925039 9/9
a)
b)
c)
d)
e)
Alternativas:
I) inicia_fila; II) remove_fila; III) fila_vazia; IV) insere_fila.
I) fila_vazia; II) remove_fila; III) inicia_fila; IV) insere_fila.
I) inicia_fila; II) insere_fila; III) fila_vazia; IV) remove_fila. Alternativa assinalada
I) fila_vazia; II) insere_fila; III) inicia_fila; IV) remove_fila.
I) remove_fila; II) insere_fila; III) fila_vazia; IV) inicia_fila.